content: {-# LANGUAGE DataKinds #-}
  {-# LANGUAGE DerivingStrategies #-}
  {-# LANGUAGE DuplicateRecordFields #-}
  {-# LANGUAGE ImportQualifiedPost #-}
  {-# LANGUAGE LambdaCase #-}
  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE PatternSynonyms #-}
  {-# LANGUAGE RecordWildCards #-}
  {-# LANGUAGE StrictData #-}
  {-# LANGUAGE TypeFamilies #-}
  {-# LANGUAGE NoImplicitPrelude #-}
  {-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
  {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
  {-# OPTIONS_GHC -fno-warn-unused-binds #-}
  {-# OPTIONS_GHC -fno-warn-unused-imports #-}
  {-# OPTIONS_GHC -fno-warn-unused-matches #-}
  
  -- |
  -- Module      : Gogol.Gmail.Internal.Product
  -- Copyright   : (c) 2015-2025 Brendan Hay
  -- License     : Mozilla Public License, v. 2.0.
  -- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
  --               Toni Cebrián <toni@tonicebrian.com>
  -- Stability   : auto-generated
  -- Portability : non-portable (GHC extensions)
  module Gogol.Gmail.Internal.Product
    ( -- * AutoForwarding
      AutoForwarding (..),
      newAutoForwarding,
  
      -- * BatchDeleteMessagesRequest
      BatchDeleteMessagesRequest (..),
      newBatchDeleteMessagesRequest,
  
      -- * BatchModifyMessagesRequest
      BatchModifyMessagesRequest (..),
      newBatchModifyMessagesRequest,
  
      -- * CseIdentity
      CseIdentity (..),
      newCseIdentity,
  
      -- * CseKeyPair
      CseKeyPair (..),
      newCseKeyPair,
  
      -- * CsePrivateKeyMetadata
      CsePrivateKeyMetadata (..),
      newCsePrivateKeyMetadata,
  
      -- * Delegate
      Delegate (..),
      newDelegate,
  
      -- * DisableCseKeyPairRequest
      DisableCseKeyPairRequest (..),
      newDisableCseKeyPairRequest,
  
      -- * Draft
      Draft (..),
      newDraft,
  
      -- * EnableCseKeyPairRequest
      EnableCseKeyPairRequest (..),
      newEnableCseKeyPairRequest,
  
      -- * Filter
      Filter (..),
      newFilter,
  
      -- * FilterAction
      FilterAction (..),
      newFilterAction,
  
      -- * FilterCriteria
      FilterCriteria (..),
      newFilterCriteria,
  
      -- * ForwardingAddress
      ForwardingAddress (..),
      newForwardingAddress,
  
      -- * HardwareKeyMetadata
      HardwareKeyMetadata (..),
      newHardwareKeyMetadata,
  
      -- * History
      History (..),
      newHistory,
  
      -- * HistoryLabelAdded
      HistoryLabelAdded (..),
      newHistoryLabelAdded,
  
      -- * HistoryLabelRemoved
      HistoryLabelRemoved (..),
      newHistoryLabelRemoved,
  
      -- * HistoryMessageAdded
      HistoryMessageAdded (..),
      newHistoryMessageAdded,
  
      -- * HistoryMessageDeleted
      HistoryMessageDeleted (..),
      newHistoryMessageDeleted,
  
      -- * ImapSettings
      ImapSettings (..),
      newImapSettings,
  
      -- * KaclsKeyMetadata
      KaclsKeyMetadata (..),
      newKaclsKeyMetadata,
  
      -- * Label
      Label (..),
      newLabel,
  
      -- * LabelColor
      LabelColor (..),
      newLabelColor,
  
      -- * LanguageSettings
      LanguageSettings (..),
      newLanguageSettings,
  
      -- * ListCseIdentitiesResponse
      ListCseIdentitiesResponse (..),
      newListCseIdentitiesResponse,
  
      -- * ListCseKeyPairsResponse
      ListCseKeyPairsResponse (..),
      newListCseKeyPairsResponse,
  
      -- * ListDelegatesResponse
      ListDelegatesResponse (..),
      newListDelegatesResponse,
  
      -- * ListDraftsResponse
      ListDraftsResponse (..),
      newListDraftsResponse,
  
      -- * ListFiltersResponse
      ListFiltersResponse (..),
      newListFiltersResponse,
  
      -- * ListForwardingAddressesResponse
      ListForwardingAddressesResponse (..),
      newListForwardingAddressesResponse,
  
      -- * ListHistoryResponse
      ListHistoryResponse (..),
      newListHistoryResponse,
  
      -- * ListLabelsResponse
      ListLabelsResponse (..),
      newListLabelsResponse,
  
      -- * ListMessagesResponse
      ListMessagesResponse (..),
      newListMessagesResponse,
  
      -- * ListSendAsResponse
      ListSendAsResponse (..),
      newListSendAsResponse,
  
      -- * ListSmimeInfoResponse
      ListSmimeInfoResponse (..),
      newListSmimeInfoResponse,
  
      -- * ListThreadsResponse
      ListThreadsResponse (..),
      newListThreadsResponse,
  
      -- * Message
      Message (..),
      newMessage,
  
      -- * MessagePart
      MessagePart (..),
      newMessagePart,
  
      -- * MessagePartBody
      MessagePartBody (..),
      newMessagePartBody,
  
      -- * MessagePartHeader
      MessagePartHeader (..),
      newMessagePartHeader,
  
      -- * ModifyMessageRequest
      ModifyMessageRequest (..),
      newModifyMessageRequest,
  
      -- * ModifyThreadRequest
      ModifyThreadRequest (..),
      newModifyThreadRequest,
  
      -- * ObliterateCseKeyPairRequest
      ObliterateCseKeyPairRequest (..),
      newObliterateCseKeyPairRequest,
  
      -- * PopSettings
      PopSettings (..),
      newPopSettings,
  
      -- * Profile
      Profile (..),
      newProfile,
  
      -- * SendAs
      SendAs (..),
      newSendAs,
  
      -- * SignAndEncryptKeyPairs
      SignAndEncryptKeyPairs (..),
      newSignAndEncryptKeyPairs,
  
      -- * SmimeInfo
      SmimeInfo (..),
      newSmimeInfo,
  
      -- * SmtpMsa
      SmtpMsa (..),
      newSmtpMsa,
  
      -- * Thread
      Thread (..),
      newThread,
  
      -- * VacationSettings
      VacationSettings (..),
      newVacationSettings,
  
      -- * WatchRequest
      WatchRequest (..),
      newWatchRequest,
  
      -- * WatchResponse
      WatchResponse (..),
      newWatchResponse,
    )
  where
  
  import Gogol.Gmail.Internal.Sum
  import Gogol.Prelude qualified as Core
  
  -- | Auto-forwarding settings for an account.
  --
  -- /See:/ 'newAutoForwarding' smart constructor.
  data AutoForwarding = AutoForwarding
    { -- | The state that a message should be left in after it has been forwarded.
      disposition :: (Core.Maybe AutoForwarding_Disposition),
      -- | Email address to which all incoming messages are forwarded. This email address must be a verified member of the forwarding addresses.
      emailAddress :: (Core.Maybe Core.Text),
      -- | Whether all incoming mail is automatically forwarded to another address.
      enabled :: (Core.Maybe Core.Bool)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'AutoForwarding' with the minimum fields required to make a request.
  newAutoForwarding ::
    AutoForwarding
  newAutoForwarding =
    AutoForwarding
      { disposition = Core.Nothing,
        emailAddress = Core.Nothing,
        enabled = Core.Nothing
      }
  
  instance Core.FromJSON AutoForwarding where
    parseJSON =
      Core.withObject
        "AutoForwarding"
        ( \o ->
            AutoForwarding
              Core.<$> (o Core..:? "disposition")
              Core.<*> (o Core..:? "emailAddress")
              Core.<*> (o Core..:? "enabled")
        )
  
  instance Core.ToJSON AutoForwarding where
    toJSON AutoForwarding {..} =
      Core.object
        ( Core.catMaybes
            [ ("disposition" Core..=) Core.<$> disposition,
              ("emailAddress" Core..=) Core.<$> emailAddress,
              ("enabled" Core..=) Core.<$> enabled
            ]
        )
  
  --
  -- /See:/ 'newBatchDeleteMessagesRequest' smart constructor.
  newtype BatchDeleteMessagesRequest = BatchDeleteMessagesRequest
    { -- | The IDs of the messages to delete.
      ids :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BatchDeleteMessagesRequest' with the minimum fields required to make a request.
  newBatchDeleteMessagesRequest ::
    BatchDeleteMessagesRequest
  newBatchDeleteMessagesRequest =
    BatchDeleteMessagesRequest {ids = Core.Nothing}
  
  instance Core.FromJSON BatchDeleteMessagesRequest where
    parseJSON =
      Core.withObject
        "BatchDeleteMessagesRequest"
        (\o -> BatchDeleteMessagesRequest Core.<$> (o Core..:? "ids"))
  
  instance Core.ToJSON BatchDeleteMessagesRequest where
    toJSON BatchDeleteMessagesRequest {..} =
      Core.object (Core.catMaybes [("ids" Core..=) Core.<$> ids])
  
  --
  -- /See:/ 'newBatchModifyMessagesRequest' smart constructor.
  data BatchModifyMessagesRequest = BatchModifyMessagesRequest
    { -- | A list of label IDs to add to messages.
      addLabelIds :: (Core.Maybe [Core.Text]),
      -- | The IDs of the messages to modify. There is a limit of 1000 ids per request.
      ids :: (Core.Maybe [Core.Text]),
      -- | A list of label IDs to remove from messages.
      removeLabelIds :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'BatchModifyMessagesRequest' with the minimum fields required to make a request.
  newBatchModifyMessagesRequest ::
    BatchModifyMessagesRequest
  newBatchModifyMessagesRequest =
    BatchModifyMessagesRequest
      { addLabelIds = Core.Nothing,
        ids = Core.Nothing,
        removeLabelIds = Core.Nothing
      }
  
  instance Core.FromJSON BatchModifyMessagesRequest where
    parseJSON =
      Core.withObject
        "BatchModifyMessagesRequest"
        ( \o ->
            BatchModifyMessagesRequest
              Core.<$> (o Core..:? "addLabelIds")
              Core.<*> (o Core..:? "ids")
              Core.<*> (o Core..:? "removeLabelIds")
        )
  
  instance Core.ToJSON BatchModifyMessagesRequest where
    toJSON BatchModifyMessagesRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("addLabelIds" Core..=) Core.<$> addLabelIds,
              ("ids" Core..=) Core.<$> ids,
              ("removeLabelIds" Core..=) Core.<$> removeLabelIds
            ]
        )
  
  -- | The client-side encryption (CSE) configuration for the email address of an authenticated user. Gmail uses CSE configurations to save drafts of client-side encrypted email messages, and to sign and send encrypted email messages.
  --
  -- /See:/ 'newCseIdentity' smart constructor.
  data CseIdentity = CseIdentity
    { -- | The email address for the sending identity. The email address must be the primary email address of the authenticated user.
      emailAddress :: (Core.Maybe Core.Text),
      -- | If a key pair is associated, the ID of the key pair, CseKeyPair.
      primaryKeyPairId :: (Core.Maybe Core.Text),
      -- | The configuration of a CSE identity that uses different key pairs for signing and encryption.
      signAndEncryptKeyPairs :: (Core.Maybe SignAndEncryptKeyPairs)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CseIdentity' with the minimum fields required to make a request.
  newCseIdentity ::
    CseIdentity
  newCseIdentity =
    CseIdentity
      { emailAddress = Core.Nothing,
        primaryKeyPairId = Core.Nothing,
        signAndEncryptKeyPairs = Core.Nothing
      }
  
  instance Core.FromJSON CseIdentity where
    parseJSON =
      Core.withObject
        "CseIdentity"
        ( \o ->
            CseIdentity
              Core.<$> (o Core..:? "emailAddress")
              Core.<*> (o Core..:? "primaryKeyPairId")
              Core.<*> (o Core..:? "signAndEncryptKeyPairs")
        )
  
  instance Core.ToJSON CseIdentity where
    toJSON CseIdentity {..} =
      Core.object
        ( Core.catMaybes
            [ ("emailAddress" Core..=) Core.<$> emailAddress,
              ("primaryKeyPairId" Core..=) Core.<$> primaryKeyPairId,
              ("signAndEncryptKeyPairs" Core..=)
                Core.<$> signAndEncryptKeyPairs
            ]
        )
  
  -- | A client-side encryption S\/MIME key pair, which is comprised of a public key, its certificate chain, and metadata for its paired private key. Gmail uses the key pair to complete the following tasks: - Sign outgoing client-side encrypted messages. - Save and reopen drafts of client-side encrypted messages. - Save and reopen sent messages. - Decrypt incoming or archived S\/MIME messages.
  --
  -- /See:/ 'newCseKeyPair' smart constructor.
  data CseKeyPair = CseKeyPair
    { -- | Output only. If a key pair is set to @DISABLED@, the time that the key pair\'s state changed from @ENABLED@ to @DISABLED@. This field is present only when the key pair is in state @DISABLED@.
      disableTime :: (Core.Maybe Core.DateTime),
      -- | Output only. The current state of the key pair.
      enablementState :: (Core.Maybe CseKeyPair_EnablementState),
      -- | Output only. The immutable ID for the client-side encryption S\/MIME key pair.
      keyPairId :: (Core.Maybe Core.Text),
      -- | Output only. The public key and its certificate chain, in <https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail PEM> format.
      pem :: (Core.Maybe Core.Text),
      -- | Input only. The public key and its certificate chain. The chain must be in <https://en.wikipedia.org/wiki/PKCS_7 PKCS#7> format and use PEM encoding and ASCII armor.
      pkcs7 :: (Core.Maybe Core.Text),
      -- | Metadata for instances of this key pair\'s private key.
      privateKeyMetadata :: (Core.Maybe [CsePrivateKeyMetadata]),
      -- | Output only. The email address identities that are specified on the leaf certificate.
      subjectEmailAddresses :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CseKeyPair' with the minimum fields required to make a request.
  newCseKeyPair ::
    CseKeyPair
  newCseKeyPair =
    CseKeyPair
      { disableTime = Core.Nothing,
        enablementState = Core.Nothing,
        keyPairId = Core.Nothing,
        pem = Core.Nothing,
        pkcs7 = Core.Nothing,
        privateKeyMetadata = Core.Nothing,
        subjectEmailAddresses = Core.Nothing
      }
  
  instance Core.FromJSON CseKeyPair where
    parseJSON =
      Core.withObject
        "CseKeyPair"
        ( \o ->
            CseKeyPair
              Core.<$> (o Core..:? "disableTime")
              Core.<*> (o Core..:? "enablementState")
              Core.<*> (o Core..:? "keyPairId")
              Core.<*> (o Core..:? "pem")
              Core.<*> (o Core..:? "pkcs7")
              Core.<*> (o Core..:? "privateKeyMetadata")
              Core.<*> (o Core..:? "subjectEmailAddresses")
        )
  
  instance Core.ToJSON CseKeyPair where
    toJSON CseKeyPair {..} =
      Core.object
        ( Core.catMaybes
            [ ("disableTime" Core..=) Core.<$> disableTime,
              ("enablementState" Core..=) Core.<$> enablementState,
              ("keyPairId" Core..=) Core.<$> keyPairId,
              ("pem" Core..=) Core.<$> pem,
              ("pkcs7" Core..=) Core.<$> pkcs7,
              ("privateKeyMetadata" Core..=) Core.<$> privateKeyMetadata,
              ("subjectEmailAddresses" Core..=) Core.<$> subjectEmailAddresses
            ]
        )
  
  -- | Metadata for a private key instance.
  --
  -- /See:/ 'newCsePrivateKeyMetadata' smart constructor.
  data CsePrivateKeyMetadata = CsePrivateKeyMetadata
    { -- | Metadata for hardware keys.
      hardwareKeyMetadata :: (Core.Maybe HardwareKeyMetadata),
      -- | Metadata for a private key instance managed by an external key access control list service.
      kaclsKeyMetadata :: (Core.Maybe KaclsKeyMetadata),
      -- | Output only. The immutable ID for the private key metadata instance.
      privateKeyMetadataId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'CsePrivateKeyMetadata' with the minimum fields required to make a request.
  newCsePrivateKeyMetadata ::
    CsePrivateKeyMetadata
  newCsePrivateKeyMetadata =
    CsePrivateKeyMetadata
      { hardwareKeyMetadata = Core.Nothing,
        kaclsKeyMetadata = Core.Nothing,
        privateKeyMetadataId = Core.Nothing
      }
  
  instance Core.FromJSON CsePrivateKeyMetadata where
    parseJSON =
      Core.withObject
        "CsePrivateKeyMetadata"
        ( \o ->
            CsePrivateKeyMetadata
              Core.<$> (o Core..:? "hardwareKeyMetadata")
              Core.<*> (o Core..:? "kaclsKeyMetadata")
              Core.<*> (o Core..:? "privateKeyMetadataId")
        )
  
  instance Core.ToJSON CsePrivateKeyMetadata where
    toJSON CsePrivateKeyMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("hardwareKeyMetadata" Core..=) Core.<$> hardwareKeyMetadata,
              ("kaclsKeyMetadata" Core..=) Core.<$> kaclsKeyMetadata,
              ("privateKeyMetadataId" Core..=) Core.<$> privateKeyMetadataId
            ]
        )
  
  -- | Settings for a delegate. Delegates can read, send, and delete messages, as well as view and add contacts, for the delegator\'s account. See \"Set up mail delegation\" for more information about delegates.
  --
  -- /See:/ 'newDelegate' smart constructor.
  data Delegate = Delegate
    { -- | The email address of the delegate.
      delegateEmail :: (Core.Maybe Core.Text),
      -- | Indicates whether this address has been verified and can act as a delegate for the account. Read-only.
      verificationStatus :: (Core.Maybe Delegate_VerificationStatus)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Delegate' with the minimum fields required to make a request.
  newDelegate ::
    Delegate
  newDelegate =
    Delegate
      { delegateEmail = Core.Nothing,
        verificationStatus = Core.Nothing
      }
  
  instance Core.FromJSON Delegate where
    parseJSON =
      Core.withObject
        "Delegate"
        ( \o ->
            Delegate
              Core.<$> (o Core..:? "delegateEmail")
              Core.<*> (o Core..:? "verificationStatus")
        )
  
  instance Core.ToJSON Delegate where
    toJSON Delegate {..} =
      Core.object
        ( Core.catMaybes
            [ ("delegateEmail" Core..=) Core.<$> delegateEmail,
              ("verificationStatus" Core..=) Core.<$> verificationStatus
            ]
        )
  
  -- | Requests to turn off a client-side encryption key pair.
  --
  -- /See:/ 'newDisableCseKeyPairRequest' smart constructor.
  data DisableCseKeyPairRequest = DisableCseKeyPairRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'DisableCseKeyPairRequest' with the minimum fields required to make a request.
  newDisableCseKeyPairRequest ::
    DisableCseKeyPairRequest
  newDisableCseKeyPairRequest = DisableCseKeyPairRequest
  
  instance Core.FromJSON DisableCseKeyPairRequest where
    parseJSON =
      Core.withObject
        "DisableCseKeyPairRequest"
        (\o -> Core.pure DisableCseKeyPairRequest)
  
  instance Core.ToJSON DisableCseKeyPairRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | A draft email in the user\'s mailbox.
  --
  -- /See:/ 'newDraft' smart constructor.
  data Draft = Draft
    { -- | The immutable ID of the draft.
      id :: (Core.Maybe Core.Text),
      -- | The message content of the draft.
      message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Draft' with the minimum fields required to make a request.
  newDraft ::
    Draft
  newDraft = Draft {id = Core.Nothing, message = Core.Nothing}
  
  instance Core.FromJSON Draft where
    parseJSON =
      Core.withObject
        "Draft"
        ( \o ->
            Draft Core.<$> (o Core..:? "id") Core.<*> (o Core..:? "message")
        )
  
  instance Core.ToJSON Draft where
    toJSON Draft {..} =
      Core.object
        ( Core.catMaybes
            [("id" Core..=) Core.<$> id, ("message" Core..=) Core.<$> message]
        )
  
  -- | Requests to turn on a client-side encryption key pair.
  --
  -- /See:/ 'newEnableCseKeyPairRequest' smart constructor.
  data EnableCseKeyPairRequest = EnableCseKeyPairRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'EnableCseKeyPairRequest' with the minimum fields required to make a request.
  newEnableCseKeyPairRequest ::
    EnableCseKeyPairRequest
  newEnableCseKeyPairRequest = EnableCseKeyPairRequest
  
  instance Core.FromJSON EnableCseKeyPairRequest where
    parseJSON =
      Core.withObject
        "EnableCseKeyPairRequest"
        (\o -> Core.pure EnableCseKeyPairRequest)
  
  instance Core.ToJSON EnableCseKeyPairRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | Resource definition for Gmail filters. Filters apply to specific messages instead of an entire email thread.
  --
  -- /See:/ 'newFilter' smart constructor.
  data Filter = Filter
    { -- | Action that the filter performs.
      action :: (Core.Maybe FilterAction),
      -- | Matching criteria for the filter.
      criteria :: (Core.Maybe FilterCriteria),
      -- | The server assigned ID of the filter.
      id :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Filter' with the minimum fields required to make a request.
  newFilter ::
    Filter
  newFilter =
    Filter
      { action = Core.Nothing,
        criteria = Core.Nothing,
        id = Core.Nothing
      }
  
  instance Core.FromJSON Filter where
    parseJSON =
      Core.withObject
        "Filter"
        ( \o ->
            Filter
              Core.<$> (o Core..:? "action")
              Core.<*> (o Core..:? "criteria")
              Core.<*> (o Core..:? "id")
        )
  
  instance Core.ToJSON Filter where
    toJSON Filter {..} =
      Core.object
        ( Core.catMaybes
            [ ("action" Core..=) Core.<$> action,
              ("criteria" Core..=) Core.<$> criteria,
              ("id" Core..=) Core.<$> id
            ]
        )
  
  -- | A set of actions to perform on a message.
  --
  -- /See:/ 'newFilterAction' smart constructor.
  data FilterAction = FilterAction
    { -- | List of labels to add to the message.
      addLabelIds :: (Core.Maybe [Core.Text]),
      -- | Email address that the message should be forwarded to.
      forward :: (Core.Maybe Core.Text),
      -- | List of labels to remove from the message.
      removeLabelIds :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FilterAction' with the minimum fields required to make a request.
  newFilterAction ::
    FilterAction
  newFilterAction =
    FilterAction
      { addLabelIds = Core.Nothing,
        forward = Core.Nothing,
        removeLabelIds = Core.Nothing
      }
  
  instance Core.FromJSON FilterAction where
    parseJSON =
      Core.withObject
        "FilterAction"
        ( \o ->
            FilterAction
              Core.<$> (o Core..:? "addLabelIds")
              Core.<*> (o Core..:? "forward")
              Core.<*> (o Core..:? "removeLabelIds")
        )
  
  instance Core.ToJSON FilterAction where
    toJSON FilterAction {..} =
      Core.object
        ( Core.catMaybes
            [ ("addLabelIds" Core..=) Core.<$> addLabelIds,
              ("forward" Core..=) Core.<$> forward,
              ("removeLabelIds" Core..=) Core.<$> removeLabelIds
            ]
        )
  
  -- | Message matching criteria.
  --
  -- /See:/ 'newFilterCriteria' smart constructor.
  data FilterCriteria = FilterCriteria
    { -- | Whether the response should exclude chats.
      excludeChats :: (Core.Maybe Core.Bool),
      -- | The sender\'s display name or email address.
      from :: (Core.Maybe Core.Text),
      -- | Whether the message has any attachment.
      hasAttachment :: (Core.Maybe Core.Bool),
      -- | Only return messages not matching the specified query. Supports the same query format as the Gmail search box. For example, @\"from:someuser\@example.com rfc822msgid: is:unread\"@.
      negatedQuery :: (Core.Maybe Core.Text),
      -- | Only return messages matching the specified query. Supports the same query format as the Gmail search box. For example, @\"from:someuser\@example.com rfc822msgid: is:unread\"@.
      query :: (Core.Maybe Core.Text),
      -- | The size of the entire RFC822 message in bytes, including all headers and attachments.
      size :: (Core.Maybe Core.Int32),
      -- | How the message size in bytes should be in relation to the size field.
      sizeComparison :: (Core.Maybe FilterCriteria_SizeComparison),
      -- | Case-insensitive phrase found in the message\'s subject. Trailing and leading whitespace are be trimmed and adjacent spaces are collapsed.
      subject :: (Core.Maybe Core.Text),
      -- | The recipient\'s display name or email address. Includes recipients in the \"to\", \"cc\", and \"bcc\" header fields. You can use simply the local part of the email address. For example, \"example\" and \"example\@\" both match \"example\@gmail.com\". This field is case-insensitive.
      to :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'FilterCriteria' with the minimum fields required to make a request.
  newFilterCriteria ::
    FilterCriteria
  newFilterCriteria =
    FilterCriteria
      { excludeChats = Core.Nothing,
        from = Core.Nothing,
        hasAttachment = Core.Nothing,
        negatedQuery = Core.Nothing,
        query = Core.Nothing,
        size = Core.Nothing,
        sizeComparison = Core.Nothing,
        subject = Core.Nothing,
        to = Core.Nothing
      }
  
  instance Core.FromJSON FilterCriteria where
    parseJSON =
      Core.withObject
        "FilterCriteria"
        ( \o ->
            FilterCriteria
              Core.<$> (o Core..:? "excludeChats")
              Core.<*> (o Core..:? "from")
              Core.<*> (o Core..:? "hasAttachment")
              Core.<*> (o Core..:? "negatedQuery")
              Core.<*> (o Core..:? "query")
              Core.<*> (o Core..:? "size")
              Core.<*> (o Core..:? "sizeComparison")
              Core.<*> (o Core..:? "subject")
              Core.<*> (o Core..:? "to")
        )
  
  instance Core.ToJSON FilterCriteria where
    toJSON FilterCriteria {..} =
      Core.object
        ( Core.catMaybes
            [ ("excludeChats" Core..=) Core.<$> excludeChats,
              ("from" Core..=) Core.<$> from,
              ("hasAttachment" Core..=) Core.<$> hasAttachment,
              ("negatedQuery" Core..=) Core.<$> negatedQuery,
              ("query" Core..=) Core.<$> query,
              ("size" Core..=) Core.<$> size,
              ("sizeComparison" Core..=) Core.<$> sizeComparison,
              ("subject" Core..=) Core.<$> subject,
              ("to" Core..=) Core.<$> to
            ]
        )
  
  -- | Settings for a forwarding address.
  --
  -- /See:/ 'newForwardingAddress' smart constructor.
  data ForwardingAddress = ForwardingAddress
    { -- | An email address to which messages can be forwarded.
      forwardingEmail :: (Core.Maybe Core.Text),
      -- | Indicates whether this address has been verified and is usable for forwarding. Read-only.
      verificationStatus :: (Core.Maybe ForwardingAddress_VerificationStatus)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ForwardingAddress' with the minimum fields required to make a request.
  newForwardingAddress ::
    ForwardingAddress
  newForwardingAddress =
    ForwardingAddress
      { forwardingEmail = Core.Nothing,
        verificationStatus = Core.Nothing
      }
  
  instance Core.FromJSON ForwardingAddress where
    parseJSON =
      Core.withObject
        "ForwardingAddress"
        ( \o ->
            ForwardingAddress
              Core.<$> (o Core..:? "forwardingEmail")
              Core.<*> (o Core..:? "verificationStatus")
        )
  
  instance Core.ToJSON ForwardingAddress where
    toJSON ForwardingAddress {..} =
      Core.object
        ( Core.catMaybes
            [ ("forwardingEmail" Core..=) Core.<$> forwardingEmail,
              ("verificationStatus" Core..=) Core.<$> verificationStatus
            ]
        )
  
  -- | Metadata for hardware keys.
  --
  -- /See:/ 'newHardwareKeyMetadata' smart constructor.
  newtype HardwareKeyMetadata = HardwareKeyMetadata
    { -- | Description about the hardware key.
      description :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HardwareKeyMetadata' with the minimum fields required to make a request.
  newHardwareKeyMetadata ::
    HardwareKeyMetadata
  newHardwareKeyMetadata =
    HardwareKeyMetadata {description = Core.Nothing}
  
  instance Core.FromJSON HardwareKeyMetadata where
    parseJSON =
      Core.withObject
        "HardwareKeyMetadata"
        (\o -> HardwareKeyMetadata Core.<$> (o Core..:? "description"))
  
  instance Core.ToJSON HardwareKeyMetadata where
    toJSON HardwareKeyMetadata {..} =
      Core.object
        (Core.catMaybes [("description" Core..=) Core.<$> description])
  
  -- | A record of a change to the user\'s mailbox. Each history change may affect multiple messages in multiple ways.
  --
  -- /See:/ 'newHistory' smart constructor.
  data History = History
    { -- | The mailbox sequence ID.
      id :: (Core.Maybe Core.Word64),
      -- | Labels added to messages in this history record.
      labelsAdded :: (Core.Maybe [HistoryLabelAdded]),
      -- | Labels removed from messages in this history record.
      labelsRemoved :: (Core.Maybe [HistoryLabelRemoved]),
      -- | List of messages changed in this history record. The fields for specific change types, such as @messagesAdded@ may duplicate messages in this field. We recommend using the specific change-type fields instead of this.
      messages :: (Core.Maybe [Message]),
      -- | Messages added to the mailbox in this history record.
      messagesAdded :: (Core.Maybe [HistoryMessageAdded]),
      -- | Messages deleted (not Trashed) from the mailbox in this history record.
      messagesDeleted :: (Core.Maybe [HistoryMessageDeleted])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'History' with the minimum fields required to make a request.
  newHistory ::
    History
  newHistory =
    History
      { id = Core.Nothing,
        labelsAdded = Core.Nothing,
        labelsRemoved = Core.Nothing,
        messages = Core.Nothing,
        messagesAdded = Core.Nothing,
        messagesDeleted = Core.Nothing
      }
  
  instance Core.FromJSON History where
    parseJSON =
      Core.withObject
        "History"
        ( \o ->
            History
              Core.<$> (o Core..:? "id" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "labelsAdded")
              Core.<*> (o Core..:? "labelsRemoved")
              Core.<*> (o Core..:? "messages")
              Core.<*> (o Core..:? "messagesAdded")
              Core.<*> (o Core..:? "messagesDeleted")
        )
  
  instance Core.ToJSON History where
    toJSON History {..} =
      Core.object
        ( Core.catMaybes
            [ ("id" Core..=) Core.. Core.AsText Core.<$> id,
              ("labelsAdded" Core..=) Core.<$> labelsAdded,
              ("labelsRemoved" Core..=) Core.<$> labelsRemoved,
              ("messages" Core..=) Core.<$> messages,
              ("messagesAdded" Core..=) Core.<$> messagesAdded,
              ("messagesDeleted" Core..=) Core.<$> messagesDeleted
            ]
        )
  
  --
  -- /See:/ 'newHistoryLabelAdded' smart constructor.
  data HistoryLabelAdded = HistoryLabelAdded
    { -- | Label IDs added to the message.
      labelIds :: (Core.Maybe [Core.Text]),
      message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HistoryLabelAdded' with the minimum fields required to make a request.
  newHistoryLabelAdded ::
    HistoryLabelAdded
  newHistoryLabelAdded =
    HistoryLabelAdded
      { labelIds = Core.Nothing,
        message = Core.Nothing
      }
  
  instance Core.FromJSON HistoryLabelAdded where
    parseJSON =
      Core.withObject
        "HistoryLabelAdded"
        ( \o ->
            HistoryLabelAdded
              Core.<$> (o Core..:? "labelIds")
              Core.<*> (o Core..:? "message")
        )
  
  instance Core.ToJSON HistoryLabelAdded where
    toJSON HistoryLabelAdded {..} =
      Core.object
        ( Core.catMaybes
            [ ("labelIds" Core..=) Core.<$> labelIds,
              ("message" Core..=) Core.<$> message
            ]
        )
  
  --
  -- /See:/ 'newHistoryLabelRemoved' smart constructor.
  data HistoryLabelRemoved = HistoryLabelRemoved
    { -- | Label IDs removed from the message.
      labelIds :: (Core.Maybe [Core.Text]),
      message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HistoryLabelRemoved' with the minimum fields required to make a request.
  newHistoryLabelRemoved ::
    HistoryLabelRemoved
  newHistoryLabelRemoved =
    HistoryLabelRemoved
      { labelIds = Core.Nothing,
        message = Core.Nothing
      }
  
  instance Core.FromJSON HistoryLabelRemoved where
    parseJSON =
      Core.withObject
        "HistoryLabelRemoved"
        ( \o ->
            HistoryLabelRemoved
              Core.<$> (o Core..:? "labelIds")
              Core.<*> (o Core..:? "message")
        )
  
  instance Core.ToJSON HistoryLabelRemoved where
    toJSON HistoryLabelRemoved {..} =
      Core.object
        ( Core.catMaybes
            [ ("labelIds" Core..=) Core.<$> labelIds,
              ("message" Core..=) Core.<$> message
            ]
        )
  
  --
  -- /See:/ 'newHistoryMessageAdded' smart constructor.
  newtype HistoryMessageAdded = HistoryMessageAdded
    { message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HistoryMessageAdded' with the minimum fields required to make a request.
  newHistoryMessageAdded ::
    HistoryMessageAdded
  newHistoryMessageAdded =
    HistoryMessageAdded {message = Core.Nothing}
  
  instance Core.FromJSON HistoryMessageAdded where
    parseJSON =
      Core.withObject
        "HistoryMessageAdded"
        (\o -> HistoryMessageAdded Core.<$> (o Core..:? "message"))
  
  instance Core.ToJSON HistoryMessageAdded where
    toJSON HistoryMessageAdded {..} =
      Core.object
        (Core.catMaybes [("message" Core..=) Core.<$> message])
  
  --
  -- /See:/ 'newHistoryMessageDeleted' smart constructor.
  newtype HistoryMessageDeleted = HistoryMessageDeleted
    { message :: (Core.Maybe Message)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'HistoryMessageDeleted' with the minimum fields required to make a request.
  newHistoryMessageDeleted ::
    HistoryMessageDeleted
  newHistoryMessageDeleted =
    HistoryMessageDeleted {message = Core.Nothing}
  
  instance Core.FromJSON HistoryMessageDeleted where
    parseJSON =
      Core.withObject
        "HistoryMessageDeleted"
        (\o -> HistoryMessageDeleted Core.<$> (o Core..:? "message"))
  
  instance Core.ToJSON HistoryMessageDeleted where
    toJSON HistoryMessageDeleted {..} =
      Core.object
        (Core.catMaybes [("message" Core..=) Core.<$> message])
  
  -- | IMAP settings for an account.
  --
  -- /See:/ 'newImapSettings' smart constructor.
  data ImapSettings = ImapSettings
    { -- | If this value is true, Gmail will immediately expunge a message when it is marked as deleted in IMAP. Otherwise, Gmail will wait for an update from the client before expunging messages marked as deleted.
      autoExpunge :: (Core.Maybe Core.Bool),
      -- | Whether IMAP is enabled for the account.
      enabled :: (Core.Maybe Core.Bool),
      -- | The action that will be executed on a message when it is marked as deleted and expunged from the last visible IMAP folder.
      expungeBehavior :: (Core.Maybe ImapSettings_ExpungeBehavior),
      -- | An optional limit on the number of messages that an IMAP folder may contain. Legal values are 0, 1000, 2000, 5000 or 10000. A value of zero is interpreted to mean that there is no limit.
      maxFolderSize :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ImapSettings' with the minimum fields required to make a request.
  newImapSettings ::
    ImapSettings
  newImapSettings =
    ImapSettings
      { autoExpunge = Core.Nothing,
        enabled = Core.Nothing,
        expungeBehavior = Core.Nothing,
        maxFolderSize = Core.Nothing
      }
  
  instance Core.FromJSON ImapSettings where
    parseJSON =
      Core.withObject
        "ImapSettings"
        ( \o ->
            ImapSettings
              Core.<$> (o Core..:? "autoExpunge")
              Core.<*> (o Core..:? "enabled")
              Core.<*> (o Core..:? "expungeBehavior")
              Core.<*> (o Core..:? "maxFolderSize")
        )
  
  instance Core.ToJSON ImapSettings where
    toJSON ImapSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("autoExpunge" Core..=) Core.<$> autoExpunge,
              ("enabled" Core..=) Core.<$> enabled,
              ("expungeBehavior" Core..=) Core.<$> expungeBehavior,
              ("maxFolderSize" Core..=) Core.<$> maxFolderSize
            ]
        )
  
  -- | Metadata for private keys managed by an external key access control list service. For details about managing key access, see <https://developers.google.com/workspace/cse/reference Google Workspace CSE API Reference>.
  --
  -- /See:/ 'newKaclsKeyMetadata' smart constructor.
  data KaclsKeyMetadata = KaclsKeyMetadata
    { -- | Opaque data generated and used by the key access control list service. Maximum size: 8 KiB.
      kaclsData :: (Core.Maybe Core.Text),
      -- | The URI of the key access control list service that manages the private key.
      kaclsUri :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'KaclsKeyMetadata' with the minimum fields required to make a request.
  newKaclsKeyMetadata ::
    KaclsKeyMetadata
  newKaclsKeyMetadata =
    KaclsKeyMetadata
      { kaclsData = Core.Nothing,
        kaclsUri = Core.Nothing
      }
  
  instance Core.FromJSON KaclsKeyMetadata where
    parseJSON =
      Core.withObject
        "KaclsKeyMetadata"
        ( \o ->
            KaclsKeyMetadata
              Core.<$> (o Core..:? "kaclsData")
              Core.<*> (o Core..:? "kaclsUri")
        )
  
  instance Core.ToJSON KaclsKeyMetadata where
    toJSON KaclsKeyMetadata {..} =
      Core.object
        ( Core.catMaybes
            [ ("kaclsData" Core..=) Core.<$> kaclsData,
              ("kaclsUri" Core..=) Core.<$> kaclsUri
            ]
        )
  
  -- | Labels are used to categorize messages and threads within the user\'s mailbox. The maximum number of labels supported for a user\'s mailbox is 10,000.
  --
  -- /See:/ 'newLabel' smart constructor.
  data Label = Label
    { -- | The color to assign to the label. Color is only available for labels that have their @type@ set to @user@.
      color :: (Core.Maybe LabelColor),
      -- | The immutable ID of the label.
      id :: (Core.Maybe Core.Text),
      -- | The visibility of the label in the label list in the Gmail web interface.
      labelListVisibility :: (Core.Maybe Label_LabelListVisibility),
      -- | The visibility of messages with this label in the message list in the Gmail web interface.
      messageListVisibility :: (Core.Maybe Label_MessageListVisibility),
      -- | The total number of messages with the label.
      messagesTotal :: (Core.Maybe Core.Int32),
      -- | The number of unread messages with the label.
      messagesUnread :: (Core.Maybe Core.Int32),
      -- | The display name of the label.
      name :: (Core.Maybe Core.Text),
      -- | The total number of threads with the label.
      threadsTotal :: (Core.Maybe Core.Int32),
      -- | The number of unread threads with the label.
      threadsUnread :: (Core.Maybe Core.Int32),
      -- | The owner type for the label. User labels are created by the user and can be modified and deleted by the user and can be applied to any message or thread. System labels are internally created and cannot be added, modified, or deleted. System labels may be able to be applied to or removed from messages and threads under some circumstances but this is not guaranteed. For example, users can apply and remove the @INBOX@ and @UNREAD@ labels from messages and threads, but cannot apply or remove the @DRAFTS@ or @SENT@ labels from messages or threads.
      type' :: (Core.Maybe Label_Type)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Label' with the minimum fields required to make a request.
  newLabel ::
    Label
  newLabel =
    Label
      { color = Core.Nothing,
        id = Core.Nothing,
        labelListVisibility = Core.Nothing,
        messageListVisibility = Core.Nothing,
        messagesTotal = Core.Nothing,
        messagesUnread = Core.Nothing,
        name = Core.Nothing,
        threadsTotal = Core.Nothing,
        threadsUnread = Core.Nothing,
        type' = Core.Nothing
      }
  
  instance Core.FromJSON Label where
    parseJSON =
      Core.withObject
        "Label"
        ( \o ->
            Label
              Core.<$> (o Core..:? "color")
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "labelListVisibility")
              Core.<*> (o Core..:? "messageListVisibility")
              Core.<*> (o Core..:? "messagesTotal")
              Core.<*> (o Core..:? "messagesUnread")
              Core.<*> (o Core..:? "name")
              Core.<*> (o Core..:? "threadsTotal")
              Core.<*> (o Core..:? "threadsUnread")
              Core.<*> (o Core..:? "type")
        )
  
  instance Core.ToJSON Label where
    toJSON Label {..} =
      Core.object
        ( Core.catMaybes
            [ ("color" Core..=) Core.<$> color,
              ("id" Core..=) Core.<$> id,
              ("labelListVisibility" Core..=) Core.<$> labelListVisibility,
              ("messageListVisibility" Core..=) Core.<$> messageListVisibility,
              ("messagesTotal" Core..=) Core.<$> messagesTotal,
              ("messagesUnread" Core..=) Core.<$> messagesUnread,
              ("name" Core..=) Core.<$> name,
              ("threadsTotal" Core..=) Core.<$> threadsTotal,
              ("threadsUnread" Core..=) Core.<$> threadsUnread,
              ("type" Core..=) Core.<$> type'
            ]
        )
  
  --
  -- /See:/ 'newLabelColor' smart constructor.
  data LabelColor = LabelColor
    { -- | The background color represented as hex string #RRGGBB (ex #000000). This field is required in order to set the color of a label. Only the following predefined set of color values are allowed: #000000, #434343, #666666, #999999, #cccccc, #efefef, #f3f3f3, #ffffff, #fb4c2f, #ffad47, #fad165, #16a766, #43d692, #4a86e8, #a479e2, #f691b3, #f6c5be, #ffe6c7, #fef1d1, #b9e4d0, #c6f3de, #c9daf8, #e4d7f5, #fcdee8, #efa093, #ffd6a2, #fce8b3, #89d3b2, #a0eac9, #a4c2f4, #d0bcf1, #fbc8d9, #e66550, #ffbc6b, #fcda83, #44b984, #68dfa9, #6d9eeb, #b694e8, #f7a7c0, #cc3a21, #eaa041, #f2c960, #149e60, #3dc789, #3c78d8, #8e63ce, #e07798, #ac2b16, #cf8933, #d5ae49, #0b804b, #2a9c68, #285bac, #653e9b, #b65775, #822111, #a46a21, #aa8831, #076239, #1a764d, #1c4587, #41236d, #83334c #464646, #e7e7e7, #0d3472, #b6cff5, #0d3b44, #98d7e4, #3d188e, #e3d7ff, #711a36, #fbd3e0, #8a1c0a, #f2b2a8, #7a2e0b, #ffc8af, #7a4706, #ffdeb5, #594c05, #fbe983, #684e07, #fdedc1, #0b4f30, #b3efd3, #04502e, #a2dcc1, #c2c2c2, #4986e7, #2da2bb, #b99aff,
      -- #994a64, #f691b2, #ff7537, #ffad46, #662e37, #ebdbde, #cca6ac, #094228, #42d692, #16a765
      backgroundColor :: (Core.Maybe Core.Text),
      -- | The text color of the label, represented as hex string. This field is required in order to set the color of a label. Only the following predefined set of color values are allowed: #000000, #434343, #666666, #999999, #cccccc, #efefef, #f3f3f3, #ffffff, #fb4c2f, #ffad47, #fad165, #16a766, #43d692, #4a86e8, #a479e2, #f691b3, #f6c5be, #ffe6c7, #fef1d1, #b9e4d0, #c6f3de, #c9daf8, #e4d7f5, #fcdee8, #efa093, #ffd6a2, #fce8b3, #89d3b2, #a0eac9, #a4c2f4, #d0bcf1, #fbc8d9, #e66550, #ffbc6b, #fcda83, #44b984, #68dfa9, #6d9eeb, #b694e8, #f7a7c0, #cc3a21, #eaa041, #f2c960, #149e60, #3dc789, #3c78d8, #8e63ce, #e07798, #ac2b16, #cf8933, #d5ae49, #0b804b, #2a9c68, #285bac, #653e9b, #b65775, #822111, #a46a21, #aa8831, #076239, #1a764d, #1c4587, #41236d, #83334c #464646, #e7e7e7, #0d3472, #b6cff5, #0d3b44, #98d7e4, #3d188e, #e3d7ff, #711a36, #fbd3e0, #8a1c0a, #f2b2a8, #7a2e0b, #ffc8af, #7a4706, #ffdeb5, #594c05, #fbe983, #684e07, #fdedc1, #0b4f30, #b3efd3, #04502e, #a2dcc1, #c2c2c2, #4986e7, #2da2bb, #b99aff, #994a64, #f691b2,
      -- #ff7537, #ffad46, #662e37, #ebdbde, #cca6ac, #094228, #42d692, #16a765
      textColor :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LabelColor' with the minimum fields required to make a request.
  newLabelColor ::
    LabelColor
  newLabelColor =
    LabelColor
      { backgroundColor = Core.Nothing,
        textColor = Core.Nothing
      }
  
  instance Core.FromJSON LabelColor where
    parseJSON =
      Core.withObject
        "LabelColor"
        ( \o ->
            LabelColor
              Core.<$> (o Core..:? "backgroundColor")
              Core.<*> (o Core..:? "textColor")
        )
  
  instance Core.ToJSON LabelColor where
    toJSON LabelColor {..} =
      Core.object
        ( Core.catMaybes
            [ ("backgroundColor" Core..=) Core.<$> backgroundColor,
              ("textColor" Core..=) Core.<$> textColor
            ]
        )
  
  -- | Language settings for an account. These settings correspond to the \"Language settings\" feature in the web interface.
  --
  -- /See:/ 'newLanguageSettings' smart constructor.
  newtype LanguageSettings = LanguageSettings
    { -- | The language to display Gmail in, formatted as an RFC 3066 Language Tag (for example @en-GB@, @fr@ or @ja@ for British English, French, or Japanese respectively). The set of languages supported by Gmail evolves over time, so please refer to the \"Language\" dropdown in the Gmail settings for all available options, as described in the language settings help article. A table of sample values is also provided in the Managing Language Settings guide Not all Gmail clients can display the same set of languages. In the case that a user\'s display language is not available for use on a particular client, said client automatically chooses to display in the closest supported variant (or a reasonable default).
      displayLanguage :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'LanguageSettings' with the minimum fields required to make a request.
  newLanguageSettings ::
    LanguageSettings
  newLanguageSettings =
    LanguageSettings {displayLanguage = Core.Nothing}
  
  instance Core.FromJSON LanguageSettings where
    parseJSON =
      Core.withObject
        "LanguageSettings"
        (\o -> LanguageSettings Core.<$> (o Core..:? "displayLanguage"))
  
  instance Core.ToJSON LanguageSettings where
    toJSON LanguageSettings {..} =
      Core.object
        ( Core.catMaybes
            [("displayLanguage" Core..=) Core.<$> displayLanguage]
        )
  
  --
  -- /See:/ 'newListCseIdentitiesResponse' smart constructor.
  data ListCseIdentitiesResponse = ListCseIdentitiesResponse
    { -- | One page of the list of CSE identities configured for the user.
      cseIdentities :: (Core.Maybe [CseIdentity]),
      -- | Pagination token to be passed to a subsequent ListCseIdentities call in order to retrieve the next page of identities. If this value is not returned or is the empty string, then no further pages remain.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListCseIdentitiesResponse' with the minimum fields required to make a request.
  newListCseIdentitiesResponse ::
    ListCseIdentitiesResponse
  newListCseIdentitiesResponse =
    ListCseIdentitiesResponse
      { cseIdentities = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListCseIdentitiesResponse where
    parseJSON =
      Core.withObject
        "ListCseIdentitiesResponse"
        ( \o ->
            ListCseIdentitiesResponse
              Core.<$> (o Core..:? "cseIdentities")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListCseIdentitiesResponse where
    toJSON ListCseIdentitiesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("cseIdentities" Core..=) Core.<$> cseIdentities,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  --
  -- /See:/ 'newListCseKeyPairsResponse' smart constructor.
  data ListCseKeyPairsResponse = ListCseKeyPairsResponse
    { -- | One page of the list of CSE key pairs installed for the user.
      cseKeyPairs :: (Core.Maybe [CseKeyPair]),
      -- | Pagination token to be passed to a subsequent ListCseKeyPairs call in order to retrieve the next page of key pairs. If this value is not returned, then no further pages remain.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListCseKeyPairsResponse' with the minimum fields required to make a request.
  newListCseKeyPairsResponse ::
    ListCseKeyPairsResponse
  newListCseKeyPairsResponse =
    ListCseKeyPairsResponse
      { cseKeyPairs = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListCseKeyPairsResponse where
    parseJSON =
      Core.withObject
        "ListCseKeyPairsResponse"
        ( \o ->
            ListCseKeyPairsResponse
              Core.<$> (o Core..:? "cseKeyPairs")
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListCseKeyPairsResponse where
    toJSON ListCseKeyPairsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("cseKeyPairs" Core..=) Core.<$> cseKeyPairs,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  -- | Response for the ListDelegates method.
  --
  -- /See:/ 'newListDelegatesResponse' smart constructor.
  newtype ListDelegatesResponse = ListDelegatesResponse
    { -- | List of the user\'s delegates (with any verification status). If an account doesn\'t have delegates, this field doesn\'t appear.
      delegates :: (Core.Maybe [Delegate])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListDelegatesResponse' with the minimum fields required to make a request.
  newListDelegatesResponse ::
    ListDelegatesResponse
  newListDelegatesResponse =
    ListDelegatesResponse {delegates = Core.Nothing}
  
  instance Core.FromJSON ListDelegatesResponse where
    parseJSON =
      Core.withObject
        "ListDelegatesResponse"
        (\o -> ListDelegatesResponse Core.<$> (o Core..:? "delegates"))
  
  instance Core.ToJSON ListDelegatesResponse where
    toJSON ListDelegatesResponse {..} =
      Core.object
        (Core.catMaybes [("delegates" Core..=) Core.<$> delegates])
  
  --
  -- /See:/ 'newListDraftsResponse' smart constructor.
  data ListDraftsResponse = ListDraftsResponse
    { -- | List of drafts. Note that the @Message@ property in each @Draft@ resource only contains an @id@ and a @threadId@. The messages.get method can fetch additional message details.
      drafts :: (Core.Maybe [Draft]),
      -- | Token to retrieve the next page of results in the list.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | Estimated total number of results.
      resultSizeEstimate :: (Core.Maybe Core.Word32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListDraftsResponse' with the minimum fields required to make a request.
  newListDraftsResponse ::
    ListDraftsResponse
  newListDraftsResponse =
    ListDraftsResponse
      { drafts = Core.Nothing,
        nextPageToken = Core.Nothing,
        resultSizeEstimate = Core.Nothing
      }
  
  instance Core.FromJSON ListDraftsResponse where
    parseJSON =
      Core.withObject
        "ListDraftsResponse"
        ( \o ->
            ListDraftsResponse
              Core.<$> (o Core..:? "drafts")
              Core.<*> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "resultSizeEstimate")
        )
  
  instance Core.ToJSON ListDraftsResponse where
    toJSON ListDraftsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("drafts" Core..=) Core.<$> drafts,
              ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("resultSizeEstimate" Core..=) Core.<$> resultSizeEstimate
            ]
        )
  
  -- | Response for the ListFilters method.
  --
  -- /See:/ 'newListFiltersResponse' smart constructor.
  newtype ListFiltersResponse = ListFiltersResponse
    { -- | List of a user\'s filters.
      filter :: (Core.Maybe [Filter])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListFiltersResponse' with the minimum fields required to make a request.
  newListFiltersResponse ::
    ListFiltersResponse
  newListFiltersResponse = ListFiltersResponse {filter = Core.Nothing}
  
  instance Core.FromJSON ListFiltersResponse where
    parseJSON =
      Core.withObject
        "ListFiltersResponse"
        (\o -> ListFiltersResponse Core.<$> (o Core..:? "filter"))
  
  instance Core.ToJSON ListFiltersResponse where
    toJSON ListFiltersResponse {..} =
      Core.object (Core.catMaybes [("filter" Core..=) Core.<$> filter])
  
  -- | Response for the ListForwardingAddresses method.
  --
  -- /See:/ 'newListForwardingAddressesResponse' smart constructor.
  newtype ListForwardingAddressesResponse = ListForwardingAddressesResponse
    { -- | List of addresses that may be used for forwarding.
      forwardingAddresses :: (Core.Maybe [ForwardingAddress])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListForwardingAddressesResponse' with the minimum fields required to make a request.
  newListForwardingAddressesResponse ::
    ListForwardingAddressesResponse
  newListForwardingAddressesResponse =
    ListForwardingAddressesResponse
      { forwardingAddresses =
          Core.Nothing
      }
  
  instance Core.FromJSON ListForwardingAddressesResponse where
    parseJSON =
      Core.withObject
        "ListForwardingAddressesResponse"
        ( \o ->
            ListForwardingAddressesResponse
              Core.<$> (o Core..:? "forwardingAddresses")
        )
  
  instance Core.ToJSON ListForwardingAddressesResponse where
    toJSON ListForwardingAddressesResponse {..} =
      Core.object
        ( Core.catMaybes
            [("forwardingAddresses" Core..=) Core.<$> forwardingAddresses]
        )
  
  --
  -- /See:/ 'newListHistoryResponse' smart constructor.
  data ListHistoryResponse = ListHistoryResponse
    { -- | List of history records. Any @messages@ contained in the response will typically only have @id@ and @threadId@ fields populated.
      history :: (Core.Maybe [History]),
      -- | The ID of the mailbox\'s current history record.
      historyId :: (Core.Maybe Core.Word64),
      -- | Page token to retrieve the next page of results in the list.
      nextPageToken :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListHistoryResponse' with the minimum fields required to make a request.
  newListHistoryResponse ::
    ListHistoryResponse
  newListHistoryResponse =
    ListHistoryResponse
      { history = Core.Nothing,
        historyId = Core.Nothing,
        nextPageToken = Core.Nothing
      }
  
  instance Core.FromJSON ListHistoryResponse where
    parseJSON =
      Core.withObject
        "ListHistoryResponse"
        ( \o ->
            ListHistoryResponse
              Core.<$> (o Core..:? "history")
              Core.<*> (o Core..:? "historyId" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "nextPageToken")
        )
  
  instance Core.ToJSON ListHistoryResponse where
    toJSON ListHistoryResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("history" Core..=) Core.<$> history,
              ("historyId" Core..=) Core.. Core.AsText Core.<$> historyId,
              ("nextPageToken" Core..=) Core.<$> nextPageToken
            ]
        )
  
  --
  -- /See:/ 'newListLabelsResponse' smart constructor.
  newtype ListLabelsResponse = ListLabelsResponse
    { -- | List of labels. Note that each label resource only contains an @id@, @name@, @messageListVisibility@, @labelListVisibility@, and @type@. The labels.get method can fetch additional label details.
      labels :: (Core.Maybe [Label])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListLabelsResponse' with the minimum fields required to make a request.
  newListLabelsResponse ::
    ListLabelsResponse
  newListLabelsResponse = ListLabelsResponse {labels = Core.Nothing}
  
  instance Core.FromJSON ListLabelsResponse where
    parseJSON =
      Core.withObject
        "ListLabelsResponse"
        (\o -> ListLabelsResponse Core.<$> (o Core..:? "labels"))
  
  instance Core.ToJSON ListLabelsResponse where
    toJSON ListLabelsResponse {..} =
      Core.object (Core.catMaybes [("labels" Core..=) Core.<$> labels])
  
  --
  -- /See:/ 'newListMessagesResponse' smart constructor.
  data ListMessagesResponse = ListMessagesResponse
    { -- | List of messages. Note that each message resource contains only an @id@ and a @threadId@. Additional message details can be fetched using the messages.get method.
      messages :: (Core.Maybe [Message]),
      -- | Token to retrieve the next page of results in the list.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | Estimated total number of results.
      resultSizeEstimate :: (Core.Maybe Core.Word32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListMessagesResponse' with the minimum fields required to make a request.
  newListMessagesResponse ::
    ListMessagesResponse
  newListMessagesResponse =
    ListMessagesResponse
      { messages = Core.Nothing,
        nextPageToken = Core.Nothing,
        resultSizeEstimate = Core.Nothing
      }
  
  instance Core.FromJSON ListMessagesResponse where
    parseJSON =
      Core.withObject
        "ListMessagesResponse"
        ( \o ->
            ListMessagesResponse
              Core.<$> (o Core..:? "messages")
              Core.<*> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "resultSizeEstimate")
        )
  
  instance Core.ToJSON ListMessagesResponse where
    toJSON ListMessagesResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("messages" Core..=) Core.<$> messages,
              ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("resultSizeEstimate" Core..=) Core.<$> resultSizeEstimate
            ]
        )
  
  -- | Response for the ListSendAs method.
  --
  -- /See:/ 'newListSendAsResponse' smart constructor.
  newtype ListSendAsResponse = ListSendAsResponse
    { -- | List of send-as aliases.
      sendAs :: (Core.Maybe [SendAs])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListSendAsResponse' with the minimum fields required to make a request.
  newListSendAsResponse ::
    ListSendAsResponse
  newListSendAsResponse = ListSendAsResponse {sendAs = Core.Nothing}
  
  instance Core.FromJSON ListSendAsResponse where
    parseJSON =
      Core.withObject
        "ListSendAsResponse"
        (\o -> ListSendAsResponse Core.<$> (o Core..:? "sendAs"))
  
  instance Core.ToJSON ListSendAsResponse where
    toJSON ListSendAsResponse {..} =
      Core.object (Core.catMaybes [("sendAs" Core..=) Core.<$> sendAs])
  
  --
  -- /See:/ 'newListSmimeInfoResponse' smart constructor.
  newtype ListSmimeInfoResponse = ListSmimeInfoResponse
    { -- | List of SmimeInfo.
      smimeInfo :: (Core.Maybe [SmimeInfo])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListSmimeInfoResponse' with the minimum fields required to make a request.
  newListSmimeInfoResponse ::
    ListSmimeInfoResponse
  newListSmimeInfoResponse =
    ListSmimeInfoResponse {smimeInfo = Core.Nothing}
  
  instance Core.FromJSON ListSmimeInfoResponse where
    parseJSON =
      Core.withObject
        "ListSmimeInfoResponse"
        (\o -> ListSmimeInfoResponse Core.<$> (o Core..:? "smimeInfo"))
  
  instance Core.ToJSON ListSmimeInfoResponse where
    toJSON ListSmimeInfoResponse {..} =
      Core.object
        (Core.catMaybes [("smimeInfo" Core..=) Core.<$> smimeInfo])
  
  --
  -- /See:/ 'newListThreadsResponse' smart constructor.
  data ListThreadsResponse = ListThreadsResponse
    { -- | Page token to retrieve the next page of results in the list.
      nextPageToken :: (Core.Maybe Core.Text),
      -- | Estimated total number of results.
      resultSizeEstimate :: (Core.Maybe Core.Word32),
      -- | List of threads. Note that each thread resource does not contain a list of @messages@. The list of @messages@ for a given thread can be fetched using the threads.get method.
      threads :: (Core.Maybe [Thread])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ListThreadsResponse' with the minimum fields required to make a request.
  newListThreadsResponse ::
    ListThreadsResponse
  newListThreadsResponse =
    ListThreadsResponse
      { nextPageToken = Core.Nothing,
        resultSizeEstimate = Core.Nothing,
        threads = Core.Nothing
      }
  
  instance Core.FromJSON ListThreadsResponse where
    parseJSON =
      Core.withObject
        "ListThreadsResponse"
        ( \o ->
            ListThreadsResponse
              Core.<$> (o Core..:? "nextPageToken")
              Core.<*> (o Core..:? "resultSizeEstimate")
              Core.<*> (o Core..:? "threads")
        )
  
  instance Core.ToJSON ListThreadsResponse where
    toJSON ListThreadsResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("nextPageToken" Core..=) Core.<$> nextPageToken,
              ("resultSizeEstimate" Core..=) Core.<$> resultSizeEstimate,
              ("threads" Core..=) Core.<$> threads
            ]
        )
  
  -- | An email message.
  --
  -- /See:/ 'newMessage' smart constructor.
  data Message = Message
    { -- | The ID of the last history record that modified this message.
      historyId :: (Core.Maybe Core.Word64),
      -- | The immutable ID of the message.
      id :: (Core.Maybe Core.Text),
      -- | The internal message creation timestamp (epoch ms), which determines ordering in the inbox. For normal SMTP-received email, this represents the time the message was originally accepted by Google, which is more reliable than the @Date@ header. However, for API-migrated mail, it can be configured by client to be based on the @Date@ header.
      internalDate :: (Core.Maybe Core.Int64),
      -- | List of IDs of labels applied to this message.
      labelIds :: (Core.Maybe [Core.Text]),
      -- | The parsed email structure in the message parts.
      payload :: (Core.Maybe MessagePart),
      -- | The entire email message in an RFC 2822 formatted and base64url encoded string. Returned in @messages.get@ and @drafts.get@ responses when the @format=RAW@ parameter is supplied.
      raw :: (Core.Maybe Core.Base64),
      -- | Estimated size in bytes of the message.
      sizeEstimate :: (Core.Maybe Core.Int32),
      -- | A short part of the message text.
      snippet :: (Core.Maybe Core.Text),
      -- | The ID of the thread the message belongs to. To add a message or draft to a thread, the following criteria must be met: 1. The requested @threadId@ must be specified on the @Message@ or @Draft.Message@ you supply with your request. 2. The @References@ and @In-Reply-To@ headers must be set in compliance with the <https://tools.ietf.org/html/rfc2822 RFC 2822> standard. 3. The @Subject@ headers must match.
      threadId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Message' with the minimum fields required to make a request.
  newMessage ::
    Message
  newMessage =
    Message
      { historyId = Core.Nothing,
        id = Core.Nothing,
        internalDate = Core.Nothing,
        labelIds = Core.Nothing,
        payload = Core.Nothing,
        raw = Core.Nothing,
        sizeEstimate = Core.Nothing,
        snippet = Core.Nothing,
        threadId = Core.Nothing
      }
  
  instance Core.FromJSON Message where
    parseJSON =
      Core.withObject
        "Message"
        ( \o ->
            Message
              Core.<$> (o Core..:? "historyId" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "internalDate" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "labelIds")
              Core.<*> (o Core..:? "payload")
              Core.<*> (o Core..:? "raw")
              Core.<*> (o Core..:? "sizeEstimate")
              Core.<*> (o Core..:? "snippet")
              Core.<*> (o Core..:? "threadId")
        )
  
  instance Core.ToJSON Message where
    toJSON Message {..} =
      Core.object
        ( Core.catMaybes
            [ ("historyId" Core..=) Core.. Core.AsText Core.<$> historyId,
              ("id" Core..=) Core.<$> id,
              ("internalDate" Core..=) Core.. Core.AsText Core.<$> internalDate,
              ("labelIds" Core..=) Core.<$> labelIds,
              ("payload" Core..=) Core.<$> payload,
              ("raw" Core..=) Core.<$> raw,
              ("sizeEstimate" Core..=) Core.<$> sizeEstimate,
              ("snippet" Core..=) Core.<$> snippet,
              ("threadId" Core..=) Core.<$> threadId
            ]
        )
  
  -- | A single MIME message part.
  --
  -- /See:/ 'newMessagePart' smart constructor.
  data MessagePart = MessagePart
    { -- | The message part body for this part, which may be empty for container MIME message parts.
      body :: (Core.Maybe MessagePartBody),
      -- | The filename of the attachment. Only present if this message part represents an attachment.
      filename :: (Core.Maybe Core.Text),
      -- | List of headers on this message part. For the top-level message part, representing the entire message payload, it will contain the standard RFC 2822 email headers such as @To@, @From@, and @Subject@.
      headers :: (Core.Maybe [MessagePartHeader]),
      -- | The MIME type of the message part.
      mimeType :: (Core.Maybe Core.Text),
      -- | The immutable ID of the message part.
      partId :: (Core.Maybe Core.Text),
      -- | The child MIME message parts of this part. This only applies to container MIME message parts, for example @multipart\/*@. For non- container MIME message part types, such as @text\/plain@, this field is empty. For more information, see RFC 1521.
      parts :: (Core.Maybe [MessagePart])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MessagePart' with the minimum fields required to make a request.
  newMessagePart ::
    MessagePart
  newMessagePart =
    MessagePart
      { body = Core.Nothing,
        filename = Core.Nothing,
        headers = Core.Nothing,
        mimeType = Core.Nothing,
        partId = Core.Nothing,
        parts = Core.Nothing
      }
  
  instance Core.FromJSON MessagePart where
    parseJSON =
      Core.withObject
        "MessagePart"
        ( \o ->
            MessagePart
              Core.<$> (o Core..:? "body")
              Core.<*> (o Core..:? "filename")
              Core.<*> (o Core..:? "headers")
              Core.<*> (o Core..:? "mimeType")
              Core.<*> (o Core..:? "partId")
              Core.<*> (o Core..:? "parts")
        )
  
  instance Core.ToJSON MessagePart where
    toJSON MessagePart {..} =
      Core.object
        ( Core.catMaybes
            [ ("body" Core..=) Core.<$> body,
              ("filename" Core..=) Core.<$> filename,
              ("headers" Core..=) Core.<$> headers,
              ("mimeType" Core..=) Core.<$> mimeType,
              ("partId" Core..=) Core.<$> partId,
              ("parts" Core..=) Core.<$> parts
            ]
        )
  
  -- | The body of a single MIME message part.
  --
  -- /See:/ 'newMessagePartBody' smart constructor.
  data MessagePartBody = MessagePartBody
    { -- | When present, contains the ID of an external attachment that can be retrieved in a separate @messages.attachments.get@ request. When not present, the entire content of the message part body is contained in the data field.
      attachmentId :: (Core.Maybe Core.Text),
      -- | The body data of a MIME message part as a base64url encoded string. May be empty for MIME container types that have no message body or when the body data is sent as a separate attachment. An attachment ID is present if the body data is contained in a separate attachment.
      data' :: (Core.Maybe Core.Base64),
      -- | Number of bytes for the message part data (encoding notwithstanding).
      size :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MessagePartBody' with the minimum fields required to make a request.
  newMessagePartBody ::
    MessagePartBody
  newMessagePartBody =
    MessagePartBody
      { attachmentId = Core.Nothing,
        data' = Core.Nothing,
        size = Core.Nothing
      }
  
  instance Core.FromJSON MessagePartBody where
    parseJSON =
      Core.withObject
        "MessagePartBody"
        ( \o ->
            MessagePartBody
              Core.<$> (o Core..:? "attachmentId")
              Core.<*> (o Core..:? "data")
              Core.<*> (o Core..:? "size")
        )
  
  instance Core.ToJSON MessagePartBody where
    toJSON MessagePartBody {..} =
      Core.object
        ( Core.catMaybes
            [ ("attachmentId" Core..=) Core.<$> attachmentId,
              ("data" Core..=) Core.<$> data',
              ("size" Core..=) Core.<$> size
            ]
        )
  
  --
  -- /See:/ 'newMessagePartHeader' smart constructor.
  data MessagePartHeader = MessagePartHeader
    { -- | The name of the header before the @:@ separator. For example, @To@.
      name :: (Core.Maybe Core.Text),
      -- | The value of the header after the @:@ separator. For example, @someuser\@example.com@.
      value :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'MessagePartHeader' with the minimum fields required to make a request.
  newMessagePartHeader ::
    MessagePartHeader
  newMessagePartHeader =
    MessagePartHeader {name = Core.Nothing, value = Core.Nothing}
  
  instance Core.FromJSON MessagePartHeader where
    parseJSON =
      Core.withObject
        "MessagePartHeader"
        ( \o ->
            MessagePartHeader
              Core.<$> (o Core..:? "name")
              Core.<*> (o Core..:? "value")
        )
  
  instance Core.ToJSON MessagePartHeader where
    toJSON MessagePartHeader {..} =
      Core.object
        ( Core.catMaybes
            [("name" Core..=) Core.<$> name, ("value" Core..=) Core.<$> value]
        )
  
  --
  -- /See:/ 'newModifyMessageRequest' smart constructor.
  data ModifyMessageRequest = ModifyMessageRequest
    { -- | A list of IDs of labels to add to this message. You can add up to 100 labels with each update.
      addLabelIds :: (Core.Maybe [Core.Text]),
      -- | A list IDs of labels to remove from this message. You can remove up to 100 labels with each update.
      removeLabelIds :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ModifyMessageRequest' with the minimum fields required to make a request.
  newModifyMessageRequest ::
    ModifyMessageRequest
  newModifyMessageRequest =
    ModifyMessageRequest
      { addLabelIds = Core.Nothing,
        removeLabelIds = Core.Nothing
      }
  
  instance Core.FromJSON ModifyMessageRequest where
    parseJSON =
      Core.withObject
        "ModifyMessageRequest"
        ( \o ->
            ModifyMessageRequest
              Core.<$> (o Core..:? "addLabelIds")
              Core.<*> (o Core..:? "removeLabelIds")
        )
  
  instance Core.ToJSON ModifyMessageRequest where
    toJSON ModifyMessageRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("addLabelIds" Core..=) Core.<$> addLabelIds,
              ("removeLabelIds" Core..=) Core.<$> removeLabelIds
            ]
        )
  
  --
  -- /See:/ 'newModifyThreadRequest' smart constructor.
  data ModifyThreadRequest = ModifyThreadRequest
    { -- | A list of IDs of labels to add to this thread. You can add up to 100 labels with each update.
      addLabelIds :: (Core.Maybe [Core.Text]),
      -- | A list of IDs of labels to remove from this thread. You can remove up to 100 labels with each update.
      removeLabelIds :: (Core.Maybe [Core.Text])
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ModifyThreadRequest' with the minimum fields required to make a request.
  newModifyThreadRequest ::
    ModifyThreadRequest
  newModifyThreadRequest =
    ModifyThreadRequest
      { addLabelIds = Core.Nothing,
        removeLabelIds = Core.Nothing
      }
  
  instance Core.FromJSON ModifyThreadRequest where
    parseJSON =
      Core.withObject
        "ModifyThreadRequest"
        ( \o ->
            ModifyThreadRequest
              Core.<$> (o Core..:? "addLabelIds")
              Core.<*> (o Core..:? "removeLabelIds")
        )
  
  instance Core.ToJSON ModifyThreadRequest where
    toJSON ModifyThreadRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("addLabelIds" Core..=) Core.<$> addLabelIds,
              ("removeLabelIds" Core..=) Core.<$> removeLabelIds
            ]
        )
  
  -- | Request to obliterate a CSE key pair.
  --
  -- /See:/ 'newObliterateCseKeyPairRequest' smart constructor.
  data ObliterateCseKeyPairRequest = ObliterateCseKeyPairRequest
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'ObliterateCseKeyPairRequest' with the minimum fields required to make a request.
  newObliterateCseKeyPairRequest ::
    ObliterateCseKeyPairRequest
  newObliterateCseKeyPairRequest = ObliterateCseKeyPairRequest
  
  instance Core.FromJSON ObliterateCseKeyPairRequest where
    parseJSON =
      Core.withObject
        "ObliterateCseKeyPairRequest"
        (\o -> Core.pure ObliterateCseKeyPairRequest)
  
  instance Core.ToJSON ObliterateCseKeyPairRequest where
    toJSON = Core.const Core.emptyObject
  
  -- | POP settings for an account.
  --
  -- /See:/ 'newPopSettings' smart constructor.
  data PopSettings = PopSettings
    { -- | The range of messages which are accessible via POP.
      accessWindow :: (Core.Maybe PopSettings_AccessWindow),
      -- | The action that will be executed on a message after it has been fetched via POP.
      disposition :: (Core.Maybe PopSettings_Disposition)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'PopSettings' with the minimum fields required to make a request.
  newPopSettings ::
    PopSettings
  newPopSettings =
    PopSettings
      { accessWindow = Core.Nothing,
        disposition = Core.Nothing
      }
  
  instance Core.FromJSON PopSettings where
    parseJSON =
      Core.withObject
        "PopSettings"
        ( \o ->
            PopSettings
              Core.<$> (o Core..:? "accessWindow")
              Core.<*> (o Core..:? "disposition")
        )
  
  instance Core.ToJSON PopSettings where
    toJSON PopSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("accessWindow" Core..=) Core.<$> accessWindow,
              ("disposition" Core..=) Core.<$> disposition
            ]
        )
  
  -- | Profile for a Gmail user.
  --
  -- /See:/ 'newProfile' smart constructor.
  data Profile = Profile
    { -- | The user\'s email address.
      emailAddress :: (Core.Maybe Core.Text),
      -- | The ID of the mailbox\'s current history record.
      historyId :: (Core.Maybe Core.Word64),
      -- | The total number of messages in the mailbox.
      messagesTotal :: (Core.Maybe Core.Int32),
      -- | The total number of threads in the mailbox.
      threadsTotal :: (Core.Maybe Core.Int32)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Profile' with the minimum fields required to make a request.
  newProfile ::
    Profile
  newProfile =
    Profile
      { emailAddress = Core.Nothing,
        historyId = Core.Nothing,
        messagesTotal = Core.Nothing,
        threadsTotal = Core.Nothing
      }
  
  instance Core.FromJSON Profile where
    parseJSON =
      Core.withObject
        "Profile"
        ( \o ->
            Profile
              Core.<$> (o Core..:? "emailAddress")
              Core.<*> (o Core..:? "historyId" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "messagesTotal")
              Core.<*> (o Core..:? "threadsTotal")
        )
  
  instance Core.ToJSON Profile where
    toJSON Profile {..} =
      Core.object
        ( Core.catMaybes
            [ ("emailAddress" Core..=) Core.<$> emailAddress,
              ("historyId" Core..=) Core.. Core.AsText Core.<$> historyId,
              ("messagesTotal" Core..=) Core.<$> messagesTotal,
              ("threadsTotal" Core..=) Core.<$> threadsTotal
            ]
        )
  
  -- | Settings associated with a send-as alias, which can be either the primary login address associated with the account or a custom \"from\" address. Send-as aliases correspond to the \"Send Mail As\" feature in the web interface.
  --
  -- /See:/ 'newSendAs' smart constructor.
  data SendAs = SendAs
    { -- | A name that appears in the \"From:\" header for mail sent using this alias. For custom \"from\" addresses, when this is empty, Gmail will populate the \"From:\" header with the name that is used for the primary address associated with the account. If the admin has disabled the ability for users to update their name format, requests to update this field for the primary login will silently fail.
      displayName :: (Core.Maybe Core.Text),
      -- | Whether this address is selected as the default \"From:\" address in situations such as composing a new message or sending a vacation auto-reply. Every Gmail account has exactly one default send-as address, so the only legal value that clients may write to this field is @true@. Changing this from @false@ to @true@ for an address will result in this field becoming @false@ for the other previous default address.
      isDefault :: (Core.Maybe Core.Bool),
      -- | Whether this address is the primary address used to login to the account. Every Gmail account has exactly one primary address, and it cannot be deleted from the collection of send-as aliases. This field is read-only.
      isPrimary :: (Core.Maybe Core.Bool),
      -- | An optional email address that is included in a \"Reply-To:\" header for mail sent using this alias. If this is empty, Gmail will not generate a \"Reply-To:\" header.
      replyToAddress :: (Core.Maybe Core.Text),
      -- | The email address that appears in the \"From:\" header for mail sent using this alias. This is read-only for all operations except create.
      sendAsEmail :: (Core.Maybe Core.Text),
      -- | An optional HTML signature that is included in messages composed with this alias in the Gmail web UI. This signature is added to new emails only.
      signature :: (Core.Maybe Core.Text),
      -- | An optional SMTP service that will be used as an outbound relay for mail sent using this alias. If this is empty, outbound mail will be sent directly from Gmail\'s servers to the destination SMTP service. This setting only applies to custom \"from\" aliases.
      smtpMsa :: (Core.Maybe SmtpMsa),
      -- | Whether Gmail should treat this address as an alias for the user\'s primary email address. This setting only applies to custom \"from\" aliases.
      treatAsAlias :: (Core.Maybe Core.Bool),
      -- | Indicates whether this address has been verified for use as a send-as alias. Read-only. This setting only applies to custom \"from\" aliases.
      verificationStatus :: (Core.Maybe SendAs_VerificationStatus)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SendAs' with the minimum fields required to make a request.
  newSendAs ::
    SendAs
  newSendAs =
    SendAs
      { displayName = Core.Nothing,
        isDefault = Core.Nothing,
        isPrimary = Core.Nothing,
        replyToAddress = Core.Nothing,
        sendAsEmail = Core.Nothing,
        signature = Core.Nothing,
        smtpMsa = Core.Nothing,
        treatAsAlias = Core.Nothing,
        verificationStatus = Core.Nothing
      }
  
  instance Core.FromJSON SendAs where
    parseJSON =
      Core.withObject
        "SendAs"
        ( \o ->
            SendAs
              Core.<$> (o Core..:? "displayName")
              Core.<*> (o Core..:? "isDefault")
              Core.<*> (o Core..:? "isPrimary")
              Core.<*> (o Core..:? "replyToAddress")
              Core.<*> (o Core..:? "sendAsEmail")
              Core.<*> (o Core..:? "signature")
              Core.<*> (o Core..:? "smtpMsa")
              Core.<*> (o Core..:? "treatAsAlias")
              Core.<*> (o Core..:? "verificationStatus")
        )
  
  instance Core.ToJSON SendAs where
    toJSON SendAs {..} =
      Core.object
        ( Core.catMaybes
            [ ("displayName" Core..=) Core.<$> displayName,
              ("isDefault" Core..=) Core.<$> isDefault,
              ("isPrimary" Core..=) Core.<$> isPrimary,
              ("replyToAddress" Core..=) Core.<$> replyToAddress,
              ("sendAsEmail" Core..=) Core.<$> sendAsEmail,
              ("signature" Core..=) Core.<$> signature,
              ("smtpMsa" Core..=) Core.<$> smtpMsa,
              ("treatAsAlias" Core..=) Core.<$> treatAsAlias,
              ("verificationStatus" Core..=) Core.<$> verificationStatus
            ]
        )
  
  -- | The configuration of a CSE identity that uses different key pairs for signing and encryption.
  --
  -- /See:/ 'newSignAndEncryptKeyPairs' smart constructor.
  data SignAndEncryptKeyPairs = SignAndEncryptKeyPairs
    { -- | The ID of the CseKeyPair that encrypts signed outgoing mail.
      encryptionKeyPairId :: (Core.Maybe Core.Text),
      -- | The ID of the CseKeyPair that signs outgoing mail.
      signingKeyPairId :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SignAndEncryptKeyPairs' with the minimum fields required to make a request.
  newSignAndEncryptKeyPairs ::
    SignAndEncryptKeyPairs
  newSignAndEncryptKeyPairs =
    SignAndEncryptKeyPairs
      { encryptionKeyPairId = Core.Nothing,
        signingKeyPairId = Core.Nothing
      }
  
  instance Core.FromJSON SignAndEncryptKeyPairs where
    parseJSON =
      Core.withObject
        "SignAndEncryptKeyPairs"
        ( \o ->
            SignAndEncryptKeyPairs
              Core.<$> (o Core..:? "encryptionKeyPairId")
              Core.<*> (o Core..:? "signingKeyPairId")
        )
  
  instance Core.ToJSON SignAndEncryptKeyPairs where
    toJSON SignAndEncryptKeyPairs {..} =
      Core.object
        ( Core.catMaybes
            [ ("encryptionKeyPairId" Core..=) Core.<$> encryptionKeyPairId,
              ("signingKeyPairId" Core..=) Core.<$> signingKeyPairId
            ]
        )
  
  -- | An S\/MIME email config.
  --
  -- /See:/ 'newSmimeInfo' smart constructor.
  data SmimeInfo = SmimeInfo
    { -- | Encrypted key password, when key is encrypted.
      encryptedKeyPassword :: (Core.Maybe Core.Text),
      -- | When the certificate expires (in milliseconds since epoch).
      expiration :: (Core.Maybe Core.Int64),
      -- | The immutable ID for the SmimeInfo.
      id :: (Core.Maybe Core.Text),
      -- | Whether this SmimeInfo is the default one for this user\'s send-as address.
      isDefault :: (Core.Maybe Core.Bool),
      -- | The S\/MIME certificate issuer\'s common name.
      issuerCn :: (Core.Maybe Core.Text),
      -- | PEM formatted X509 concatenated certificate string (standard base64 encoding). Format used for returning key, which includes public key as well as certificate chain (not private key).
      pem :: (Core.Maybe Core.Text),
      -- | PKCS#12 format containing a single private\/public key pair and certificate chain. This format is only accepted from client for creating a new SmimeInfo and is never returned, because the private key is not intended to be exported. PKCS#12 may be encrypted, in which case encryptedKeyPassword should be set appropriately.
      pkcs12 :: (Core.Maybe Core.Base64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SmimeInfo' with the minimum fields required to make a request.
  newSmimeInfo ::
    SmimeInfo
  newSmimeInfo =
    SmimeInfo
      { encryptedKeyPassword = Core.Nothing,
        expiration = Core.Nothing,
        id = Core.Nothing,
        isDefault = Core.Nothing,
        issuerCn = Core.Nothing,
        pem = Core.Nothing,
        pkcs12 = Core.Nothing
      }
  
  instance Core.FromJSON SmimeInfo where
    parseJSON =
      Core.withObject
        "SmimeInfo"
        ( \o ->
            SmimeInfo
              Core.<$> (o Core..:? "encryptedKeyPassword")
              Core.<*> (o Core..:? "expiration" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "isDefault")
              Core.<*> (o Core..:? "issuerCn")
              Core.<*> (o Core..:? "pem")
              Core.<*> (o Core..:? "pkcs12")
        )
  
  instance Core.ToJSON SmimeInfo where
    toJSON SmimeInfo {..} =
      Core.object
        ( Core.catMaybes
            [ ("encryptedKeyPassword" Core..=) Core.<$> encryptedKeyPassword,
              ("expiration" Core..=) Core.. Core.AsText Core.<$> expiration,
              ("id" Core..=) Core.<$> id,
              ("isDefault" Core..=) Core.<$> isDefault,
              ("issuerCn" Core..=) Core.<$> issuerCn,
              ("pem" Core..=) Core.<$> pem,
              ("pkcs12" Core..=) Core.<$> pkcs12
            ]
        )
  
  -- | Configuration for communication with an SMTP service.
  --
  -- /See:/ 'newSmtpMsa' smart constructor.
  data SmtpMsa = SmtpMsa
    { -- | The hostname of the SMTP service. Required.
      host :: (Core.Maybe Core.Text),
      -- | The password that will be used for authentication with the SMTP service. This is a write-only field that can be specified in requests to create or update SendAs settings; it is never populated in responses.
      password :: (Core.Maybe Core.Text),
      -- | The port of the SMTP service. Required.
      port :: (Core.Maybe Core.Int32),
      -- | The protocol that will be used to secure communication with the SMTP service. Required.
      securityMode :: (Core.Maybe SmtpMsa_SecurityMode),
      -- | The username that will be used for authentication with the SMTP service. This is a write-only field that can be specified in requests to create or update SendAs settings; it is never populated in responses.
      username :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'SmtpMsa' with the minimum fields required to make a request.
  newSmtpMsa ::
    SmtpMsa
  newSmtpMsa =
    SmtpMsa
      { host = Core.Nothing,
        password = Core.Nothing,
        port = Core.Nothing,
        securityMode = Core.Nothing,
        username = Core.Nothing
      }
  
  instance Core.FromJSON SmtpMsa where
    parseJSON =
      Core.withObject
        "SmtpMsa"
        ( \o ->
            SmtpMsa
              Core.<$> (o Core..:? "host")
              Core.<*> (o Core..:? "password")
              Core.<*> (o Core..:? "port")
              Core.<*> (o Core..:? "securityMode")
              Core.<*> (o Core..:? "username")
        )
  
  instance Core.ToJSON SmtpMsa where
    toJSON SmtpMsa {..} =
      Core.object
        ( Core.catMaybes
            [ ("host" Core..=) Core.<$> host,
              ("password" Core..=) Core.<$> password,
              ("port" Core..=) Core.<$> port,
              ("securityMode" Core..=) Core.<$> securityMode,
              ("username" Core..=) Core.<$> username
            ]
        )
  
  -- | A collection of messages representing a conversation.
  --
  -- /See:/ 'newThread' smart constructor.
  data Thread = Thread
    { -- | The ID of the last history record that modified this thread.
      historyId :: (Core.Maybe Core.Word64),
      -- | The unique ID of the thread.
      id :: (Core.Maybe Core.Text),
      -- | The list of messages in the thread.
      messages :: (Core.Maybe [Message]),
      -- | A short part of the message text.
      snippet :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'Thread' with the minimum fields required to make a request.
  newThread ::
    Thread
  newThread =
    Thread
      { historyId = Core.Nothing,
        id = Core.Nothing,
        messages = Core.Nothing,
        snippet = Core.Nothing
      }
  
  instance Core.FromJSON Thread where
    parseJSON =
      Core.withObject
        "Thread"
        ( \o ->
            Thread
              Core.<$> (o Core..:? "historyId" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "id")
              Core.<*> (o Core..:? "messages")
              Core.<*> (o Core..:? "snippet")
        )
  
  instance Core.ToJSON Thread where
    toJSON Thread {..} =
      Core.object
        ( Core.catMaybes
            [ ("historyId" Core..=) Core.. Core.AsText Core.<$> historyId,
              ("id" Core..=) Core.<$> id,
              ("messages" Core..=) Core.<$> messages,
              ("snippet" Core..=) Core.<$> snippet
            ]
        )
  
  -- | Vacation auto-reply settings for an account. These settings correspond to the \"Vacation responder\" feature in the web interface.
  --
  -- /See:/ 'newVacationSettings' smart constructor.
  data VacationSettings = VacationSettings
    { -- | Flag that controls whether Gmail automatically replies to messages.
      enableAutoReply :: (Core.Maybe Core.Bool),
      -- | An optional end time for sending auto-replies (epoch ms). When this is specified, Gmail will automatically reply only to messages that it receives before the end time. If both @startTime@ and @endTime@ are specified, @startTime@ must precede @endTime@.
      endTime :: (Core.Maybe Core.Int64),
      -- | Response body in HTML format. Gmail will sanitize the HTML before storing it. If both @response_body_plain_text@ and @response_body_html@ are specified, @response_body_html@ will be used.
      responseBodyHtml :: (Core.Maybe Core.Text),
      -- | Response body in plain text format. If both @response_body_plain_text@ and @response_body_html@ are specified, @response_body_html@ will be used.
      responseBodyPlainText :: (Core.Maybe Core.Text),
      -- | Optional text to prepend to the subject line in vacation responses. In order to enable auto-replies, either the response subject or the response body must be nonempty.
      responseSubject :: (Core.Maybe Core.Text),
      -- | Flag that determines whether responses are sent to recipients who are not in the user\'s list of contacts.
      restrictToContacts :: (Core.Maybe Core.Bool),
      -- | Flag that determines whether responses are sent to recipients who are outside of the user\'s domain. This feature is only available for Google Workspace users.
      restrictToDomain :: (Core.Maybe Core.Bool),
      -- | An optional start time for sending auto-replies (epoch ms). When this is specified, Gmail will automatically reply only to messages that it receives after the start time. If both @startTime@ and @endTime@ are specified, @startTime@ must precede @endTime@.
      startTime :: (Core.Maybe Core.Int64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'VacationSettings' with the minimum fields required to make a request.
  newVacationSettings ::
    VacationSettings
  newVacationSettings =
    VacationSettings
      { enableAutoReply = Core.Nothing,
        endTime = Core.Nothing,
        responseBodyHtml = Core.Nothing,
        responseBodyPlainText = Core.Nothing,
        responseSubject = Core.Nothing,
        restrictToContacts = Core.Nothing,
        restrictToDomain = Core.Nothing,
        startTime = Core.Nothing
      }
  
  instance Core.FromJSON VacationSettings where
    parseJSON =
      Core.withObject
        "VacationSettings"
        ( \o ->
            VacationSettings
              Core.<$> (o Core..:? "enableAutoReply")
              Core.<*> (o Core..:? "endTime" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "responseBodyHtml")
              Core.<*> (o Core..:? "responseBodyPlainText")
              Core.<*> (o Core..:? "responseSubject")
              Core.<*> (o Core..:? "restrictToContacts")
              Core.<*> (o Core..:? "restrictToDomain")
              Core.<*> (o Core..:? "startTime" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON VacationSettings where
    toJSON VacationSettings {..} =
      Core.object
        ( Core.catMaybes
            [ ("enableAutoReply" Core..=) Core.<$> enableAutoReply,
              ("endTime" Core..=) Core.. Core.AsText Core.<$> endTime,
              ("responseBodyHtml" Core..=) Core.<$> responseBodyHtml,
              ("responseBodyPlainText" Core..=) Core.<$> responseBodyPlainText,
              ("responseSubject" Core..=) Core.<$> responseSubject,
              ("restrictToContacts" Core..=) Core.<$> restrictToContacts,
              ("restrictToDomain" Core..=) Core.<$> restrictToDomain,
              ("startTime" Core..=) Core.. Core.AsText Core.<$> startTime
            ]
        )
  
  -- | Set up or update a new push notification watch on this user\'s mailbox.
  --
  -- /See:/ 'newWatchRequest' smart constructor.
  data WatchRequest = WatchRequest
    { -- | Filtering behavior of @labelIds list@ specified. This field is deprecated because it caused incorrect behavior in some cases; use @label_filter_behavior@ instead.
      labelFilterAction :: (Core.Maybe WatchRequest_LabelFilterAction),
      -- | Filtering behavior of @labelIds list@ specified. This field replaces @label_filter_action@; if set, @label_filter_action@ is ignored.
      labelFilterBehavior :: (Core.Maybe WatchRequest_LabelFilterBehavior),
      -- | List of label_ids to restrict notifications about. By default, if unspecified, all changes are pushed out. If specified then dictates which labels are required for a push notification to be generated.
      labelIds :: (Core.Maybe [Core.Text]),
      -- | A fully qualified Google Cloud Pub\/Sub API topic name to publish the events to. This topic name __must__ already exist in Cloud Pub\/Sub and you __must__ have already granted gmail \"publish\" permission on it. For example, \"projects\/my-project-identifier\/topics\/my-topic-name\" (using the Cloud Pub\/Sub \"v1\" topic naming format). Note that the \"my-project-identifier\" portion must exactly match your Google developer project id (the one executing this watch request).
      topicName :: (Core.Maybe Core.Text)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WatchRequest' with the minimum fields required to make a request.
  newWatchRequest ::
    WatchRequest
  newWatchRequest =
    WatchRequest
      { labelFilterAction = Core.Nothing,
        labelFilterBehavior = Core.Nothing,
        labelIds = Core.Nothing,
        topicName = Core.Nothing
      }
  
  instance Core.FromJSON WatchRequest where
    parseJSON =
      Core.withObject
        "WatchRequest"
        ( \o ->
            WatchRequest
              Core.<$> (o Core..:? "labelFilterAction")
              Core.<*> (o Core..:? "labelFilterBehavior")
              Core.<*> (o Core..:? "labelIds")
              Core.<*> (o Core..:? "topicName")
        )
  
  instance Core.ToJSON WatchRequest where
    toJSON WatchRequest {..} =
      Core.object
        ( Core.catMaybes
            [ ("labelFilterAction" Core..=) Core.<$> labelFilterAction,
              ("labelFilterBehavior" Core..=) Core.<$> labelFilterBehavior,
              ("labelIds" Core..=) Core.<$> labelIds,
              ("topicName" Core..=) Core.<$> topicName
            ]
        )
  
  -- | Push notification watch response.
  --
  -- /See:/ 'newWatchResponse' smart constructor.
  data WatchResponse = WatchResponse
    { -- | When Gmail will stop sending notifications for mailbox updates (epoch millis). Call @watch@ again before this time to renew the watch.
      expiration :: (Core.Maybe Core.Int64),
      -- | The ID of the mailbox\'s current history record.
      historyId :: (Core.Maybe Core.Word64)
    }
    deriving (Core.Eq, Core.Show, Core.Generic)
  
  -- | Creates a value of 'WatchResponse' with the minimum fields required to make a request.
  newWatchResponse ::
    WatchResponse
  newWatchResponse =
    WatchResponse
      { expiration = Core.Nothing,
        historyId = Core.Nothing
      }
  
  instance Core.FromJSON WatchResponse where
    parseJSON =
      Core.withObject
        "WatchResponse"
        ( \o ->
            WatchResponse
              Core.<$> (o Core..:? "expiration" Core.<&> Core.fmap Core.fromAsText)
              Core.<*> (o Core..:? "historyId" Core.<&> Core.fmap Core.fromAsText)
        )
  
  instance Core.ToJSON WatchResponse where
    toJSON WatchResponse {..} =
      Core.object
        ( Core.catMaybes
            [ ("expiration" Core..=) Core.. Core.AsText Core.<$> expiration,
              ("historyId" Core..=) Core.. Core.AsText Core.<$> historyId
            ]
        )
  