{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.SESV2.SendEmail
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Sends an email message. You can use the Amazon SES API v2 to send the
-- following types of messages:
--
-- -   __Simple__ – A standard email message. When you create this type of
--     message, you specify the sender, the recipient, and the message
--     body, and Amazon SES assembles the message for you.
--
-- -   __Raw__ – A raw, MIME-formatted email message. When you send this
--     type of email, you have to specify all of the message headers, as
--     well as the message body. You can use this message type to send
--     messages that contain attachments. The message that you specify has
--     to be a valid MIME message.
--
-- -   __Templated__ – A message that contains personalization tags. When
--     you send this type of email, Amazon SES API v2 automatically
--     replaces the tags with values that you specify.
module Amazonka.SESV2.SendEmail
  ( -- * Creating a Request
    SendEmail (..),
    newSendEmail,

    -- * Request Lenses
    sendEmail_fromEmailAddress,
    sendEmail_destination,
    sendEmail_fromEmailAddressIdentityArn,
    sendEmail_configurationSetName,
    sendEmail_listManagementOptions,
    sendEmail_emailTags,
    sendEmail_feedbackForwardingEmailAddress,
    sendEmail_feedbackForwardingEmailAddressIdentityArn,
    sendEmail_replyToAddresses,
    sendEmail_content,

    -- * Destructuring the Response
    SendEmailResponse (..),
    newSendEmailResponse,

    -- * Response Lenses
    sendEmailResponse_messageId,
    sendEmailResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SESV2.Types

-- | Represents a request to send a single formatted email using Amazon SES.
-- For more information, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html Amazon SES Developer Guide>.
--
-- /See:/ 'newSendEmail' smart constructor.
data SendEmail = SendEmail'
  { -- | The email address to use as the \"From\" address for the email. The
    -- address that you specify has to be verified.
    SendEmail -> Maybe Text
fromEmailAddress :: Prelude.Maybe Prelude.Text,
    -- | An object that contains the recipients of the email message.
    SendEmail -> Maybe Destination
destination :: Prelude.Maybe Destination,
    -- | This parameter is used only for sending authorization. It is the ARN of
    -- the identity that is associated with the sending authorization policy
    -- that permits you to use the email address specified in the
    -- @FromEmailAddress@ parameter.
    --
    -- For example, if the owner of example.com (which has ARN
    -- arn:aws:ses:us-east-1:123456789012:identity\/example.com) attaches a
    -- policy to it that authorizes you to use sender\@example.com, then you
    -- would specify the @FromEmailAddressIdentityArn@ to be
    -- arn:aws:ses:us-east-1:123456789012:identity\/example.com, and the
    -- @FromEmailAddress@ to be sender\@example.com.
    --
    -- For more information about sending authorization, see the
    -- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
    --
    -- For Raw emails, the @FromEmailAddressIdentityArn@ value overrides the
    -- X-SES-SOURCE-ARN and X-SES-FROM-ARN headers specified in raw email
    -- message content.
    SendEmail -> Maybe Text
fromEmailAddressIdentityArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the configuration set to use when sending the email.
    SendEmail -> Maybe Text
configurationSetName :: Prelude.Maybe Prelude.Text,
    -- | An object used to specify a list or topic to which an email belongs,
    -- which will be used when a contact chooses to unsubscribe.
    SendEmail -> Maybe ListManagementOptions
listManagementOptions :: Prelude.Maybe ListManagementOptions,
    -- | A list of tags, in the form of name\/value pairs, to apply to an email
    -- that you send using the @SendEmail@ operation. Tags correspond to
    -- characteristics of the email that you define, so that you can publish
    -- email sending events.
    SendEmail -> Maybe [MessageTag]
emailTags :: Prelude.Maybe [MessageTag],
    -- | The address that you want bounce and complaint notifications to be sent
    -- to.
    SendEmail -> Maybe Text
feedbackForwardingEmailAddress :: Prelude.Maybe Prelude.Text,
    -- | This parameter is used only for sending authorization. It is the ARN of
    -- the identity that is associated with the sending authorization policy
    -- that permits you to use the email address specified in the
    -- @FeedbackForwardingEmailAddress@ parameter.
    --
    -- For example, if the owner of example.com (which has ARN
    -- arn:aws:ses:us-east-1:123456789012:identity\/example.com) attaches a
    -- policy to it that authorizes you to use feedback\@example.com, then you
    -- would specify the @FeedbackForwardingEmailAddressIdentityArn@ to be
    -- arn:aws:ses:us-east-1:123456789012:identity\/example.com, and the
    -- @FeedbackForwardingEmailAddress@ to be feedback\@example.com.
    --
    -- For more information about sending authorization, see the
    -- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
    SendEmail -> Maybe Text
feedbackForwardingEmailAddressIdentityArn :: Prelude.Maybe Prelude.Text,
    -- | The \"Reply-to\" email addresses for the message. When the recipient
    -- replies to the message, each Reply-to address receives the reply.
    SendEmail -> Maybe [Text]
replyToAddresses :: Prelude.Maybe [Prelude.Text],
    -- | An object that contains the body of the message. You can send either a
    -- Simple message Raw message or a template Message.
    SendEmail -> EmailContent
content :: EmailContent
  }
  deriving (SendEmail -> SendEmail -> Bool
(SendEmail -> SendEmail -> Bool)
-> (SendEmail -> SendEmail -> Bool) -> Eq SendEmail
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SendEmail -> SendEmail -> Bool
$c/= :: SendEmail -> SendEmail -> Bool
== :: SendEmail -> SendEmail -> Bool
$c== :: SendEmail -> SendEmail -> Bool
Prelude.Eq, ReadPrec [SendEmail]
ReadPrec SendEmail
Int -> ReadS SendEmail
ReadS [SendEmail]
(Int -> ReadS SendEmail)
-> ReadS [SendEmail]
-> ReadPrec SendEmail
-> ReadPrec [SendEmail]
-> Read SendEmail
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SendEmail]
$creadListPrec :: ReadPrec [SendEmail]
readPrec :: ReadPrec SendEmail
$creadPrec :: ReadPrec SendEmail
readList :: ReadS [SendEmail]
$creadList :: ReadS [SendEmail]
readsPrec :: Int -> ReadS SendEmail
$creadsPrec :: Int -> ReadS SendEmail
Prelude.Read, Int -> SendEmail -> ShowS
[SendEmail] -> ShowS
SendEmail -> String
(Int -> SendEmail -> ShowS)
-> (SendEmail -> String)
-> ([SendEmail] -> ShowS)
-> Show SendEmail
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SendEmail] -> ShowS
$cshowList :: [SendEmail] -> ShowS
show :: SendEmail -> String
$cshow :: SendEmail -> String
showsPrec :: Int -> SendEmail -> ShowS
$cshowsPrec :: Int -> SendEmail -> ShowS
Prelude.Show, (forall x. SendEmail -> Rep SendEmail x)
-> (forall x. Rep SendEmail x -> SendEmail) -> Generic SendEmail
forall x. Rep SendEmail x -> SendEmail
forall x. SendEmail -> Rep SendEmail x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SendEmail x -> SendEmail
$cfrom :: forall x. SendEmail -> Rep SendEmail x
Prelude.Generic)

-- |
-- Create a value of 'SendEmail' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'fromEmailAddress', 'sendEmail_fromEmailAddress' - The email address to use as the \"From\" address for the email. The
-- address that you specify has to be verified.
--
-- 'destination', 'sendEmail_destination' - An object that contains the recipients of the email message.
--
-- 'fromEmailAddressIdentityArn', 'sendEmail_fromEmailAddressIdentityArn' - This parameter is used only for sending authorization. It is the ARN of
-- the identity that is associated with the sending authorization policy
-- that permits you to use the email address specified in the
-- @FromEmailAddress@ parameter.
--
-- For example, if the owner of example.com (which has ARN
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com) attaches a
-- policy to it that authorizes you to use sender\@example.com, then you
-- would specify the @FromEmailAddressIdentityArn@ to be
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com, and the
-- @FromEmailAddress@ to be sender\@example.com.
--
-- For more information about sending authorization, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
--
-- For Raw emails, the @FromEmailAddressIdentityArn@ value overrides the
-- X-SES-SOURCE-ARN and X-SES-FROM-ARN headers specified in raw email
-- message content.
--
-- 'configurationSetName', 'sendEmail_configurationSetName' - The name of the configuration set to use when sending the email.
--
-- 'listManagementOptions', 'sendEmail_listManagementOptions' - An object used to specify a list or topic to which an email belongs,
-- which will be used when a contact chooses to unsubscribe.
--
-- 'emailTags', 'sendEmail_emailTags' - A list of tags, in the form of name\/value pairs, to apply to an email
-- that you send using the @SendEmail@ operation. Tags correspond to
-- characteristics of the email that you define, so that you can publish
-- email sending events.
--
-- 'feedbackForwardingEmailAddress', 'sendEmail_feedbackForwardingEmailAddress' - The address that you want bounce and complaint notifications to be sent
-- to.
--
-- 'feedbackForwardingEmailAddressIdentityArn', 'sendEmail_feedbackForwardingEmailAddressIdentityArn' - This parameter is used only for sending authorization. It is the ARN of
-- the identity that is associated with the sending authorization policy
-- that permits you to use the email address specified in the
-- @FeedbackForwardingEmailAddress@ parameter.
--
-- For example, if the owner of example.com (which has ARN
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com) attaches a
-- policy to it that authorizes you to use feedback\@example.com, then you
-- would specify the @FeedbackForwardingEmailAddressIdentityArn@ to be
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com, and the
-- @FeedbackForwardingEmailAddress@ to be feedback\@example.com.
--
-- For more information about sending authorization, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
--
-- 'replyToAddresses', 'sendEmail_replyToAddresses' - The \"Reply-to\" email addresses for the message. When the recipient
-- replies to the message, each Reply-to address receives the reply.
--
-- 'content', 'sendEmail_content' - An object that contains the body of the message. You can send either a
-- Simple message Raw message or a template Message.
newSendEmail ::
  -- | 'content'
  EmailContent ->
  SendEmail
newSendEmail :: EmailContent -> SendEmail
newSendEmail EmailContent
pContent_ =
  SendEmail' :: Maybe Text
-> Maybe Destination
-> Maybe Text
-> Maybe Text
-> Maybe ListManagementOptions
-> Maybe [MessageTag]
-> Maybe Text
-> Maybe Text
-> Maybe [Text]
-> EmailContent
-> SendEmail
SendEmail'
    { $sel:fromEmailAddress:SendEmail' :: Maybe Text
fromEmailAddress = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:destination:SendEmail' :: Maybe Destination
destination = Maybe Destination
forall a. Maybe a
Prelude.Nothing,
      $sel:fromEmailAddressIdentityArn:SendEmail' :: Maybe Text
fromEmailAddressIdentityArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:configurationSetName:SendEmail' :: Maybe Text
configurationSetName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:listManagementOptions:SendEmail' :: Maybe ListManagementOptions
listManagementOptions = Maybe ListManagementOptions
forall a. Maybe a
Prelude.Nothing,
      $sel:emailTags:SendEmail' :: Maybe [MessageTag]
emailTags = Maybe [MessageTag]
forall a. Maybe a
Prelude.Nothing,
      $sel:feedbackForwardingEmailAddress:SendEmail' :: Maybe Text
feedbackForwardingEmailAddress = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:feedbackForwardingEmailAddressIdentityArn:SendEmail' :: Maybe Text
feedbackForwardingEmailAddressIdentityArn =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:replyToAddresses:SendEmail' :: Maybe [Text]
replyToAddresses = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:content:SendEmail' :: EmailContent
content = EmailContent
pContent_
    }

-- | The email address to use as the \"From\" address for the email. The
-- address that you specify has to be verified.
sendEmail_fromEmailAddress :: Lens.Lens' SendEmail (Prelude.Maybe Prelude.Text)
sendEmail_fromEmailAddress :: (Maybe Text -> f (Maybe Text)) -> SendEmail -> f SendEmail
sendEmail_fromEmailAddress = (SendEmail -> Maybe Text)
-> (SendEmail -> Maybe Text -> SendEmail)
-> Lens SendEmail SendEmail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe Text
fromEmailAddress :: Maybe Text
$sel:fromEmailAddress:SendEmail' :: SendEmail -> Maybe Text
fromEmailAddress} -> Maybe Text
fromEmailAddress) (\s :: SendEmail
s@SendEmail' {} Maybe Text
a -> SendEmail
s {$sel:fromEmailAddress:SendEmail' :: Maybe Text
fromEmailAddress = Maybe Text
a} :: SendEmail)

-- | An object that contains the recipients of the email message.
sendEmail_destination :: Lens.Lens' SendEmail (Prelude.Maybe Destination)
sendEmail_destination :: (Maybe Destination -> f (Maybe Destination))
-> SendEmail -> f SendEmail
sendEmail_destination = (SendEmail -> Maybe Destination)
-> (SendEmail -> Maybe Destination -> SendEmail)
-> Lens SendEmail SendEmail (Maybe Destination) (Maybe Destination)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe Destination
destination :: Maybe Destination
$sel:destination:SendEmail' :: SendEmail -> Maybe Destination
destination} -> Maybe Destination
destination) (\s :: SendEmail
s@SendEmail' {} Maybe Destination
a -> SendEmail
s {$sel:destination:SendEmail' :: Maybe Destination
destination = Maybe Destination
a} :: SendEmail)

-- | This parameter is used only for sending authorization. It is the ARN of
-- the identity that is associated with the sending authorization policy
-- that permits you to use the email address specified in the
-- @FromEmailAddress@ parameter.
--
-- For example, if the owner of example.com (which has ARN
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com) attaches a
-- policy to it that authorizes you to use sender\@example.com, then you
-- would specify the @FromEmailAddressIdentityArn@ to be
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com, and the
-- @FromEmailAddress@ to be sender\@example.com.
--
-- For more information about sending authorization, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
--
-- For Raw emails, the @FromEmailAddressIdentityArn@ value overrides the
-- X-SES-SOURCE-ARN and X-SES-FROM-ARN headers specified in raw email
-- message content.
sendEmail_fromEmailAddressIdentityArn :: Lens.Lens' SendEmail (Prelude.Maybe Prelude.Text)
sendEmail_fromEmailAddressIdentityArn :: (Maybe Text -> f (Maybe Text)) -> SendEmail -> f SendEmail
sendEmail_fromEmailAddressIdentityArn = (SendEmail -> Maybe Text)
-> (SendEmail -> Maybe Text -> SendEmail)
-> Lens SendEmail SendEmail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe Text
fromEmailAddressIdentityArn :: Maybe Text
$sel:fromEmailAddressIdentityArn:SendEmail' :: SendEmail -> Maybe Text
fromEmailAddressIdentityArn} -> Maybe Text
fromEmailAddressIdentityArn) (\s :: SendEmail
s@SendEmail' {} Maybe Text
a -> SendEmail
s {$sel:fromEmailAddressIdentityArn:SendEmail' :: Maybe Text
fromEmailAddressIdentityArn = Maybe Text
a} :: SendEmail)

-- | The name of the configuration set to use when sending the email.
sendEmail_configurationSetName :: Lens.Lens' SendEmail (Prelude.Maybe Prelude.Text)
sendEmail_configurationSetName :: (Maybe Text -> f (Maybe Text)) -> SendEmail -> f SendEmail
sendEmail_configurationSetName = (SendEmail -> Maybe Text)
-> (SendEmail -> Maybe Text -> SendEmail)
-> Lens SendEmail SendEmail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe Text
configurationSetName :: Maybe Text
$sel:configurationSetName:SendEmail' :: SendEmail -> Maybe Text
configurationSetName} -> Maybe Text
configurationSetName) (\s :: SendEmail
s@SendEmail' {} Maybe Text
a -> SendEmail
s {$sel:configurationSetName:SendEmail' :: Maybe Text
configurationSetName = Maybe Text
a} :: SendEmail)

-- | An object used to specify a list or topic to which an email belongs,
-- which will be used when a contact chooses to unsubscribe.
sendEmail_listManagementOptions :: Lens.Lens' SendEmail (Prelude.Maybe ListManagementOptions)
sendEmail_listManagementOptions :: (Maybe ListManagementOptions -> f (Maybe ListManagementOptions))
-> SendEmail -> f SendEmail
sendEmail_listManagementOptions = (SendEmail -> Maybe ListManagementOptions)
-> (SendEmail -> Maybe ListManagementOptions -> SendEmail)
-> Lens
     SendEmail
     SendEmail
     (Maybe ListManagementOptions)
     (Maybe ListManagementOptions)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe ListManagementOptions
listManagementOptions :: Maybe ListManagementOptions
$sel:listManagementOptions:SendEmail' :: SendEmail -> Maybe ListManagementOptions
listManagementOptions} -> Maybe ListManagementOptions
listManagementOptions) (\s :: SendEmail
s@SendEmail' {} Maybe ListManagementOptions
a -> SendEmail
s {$sel:listManagementOptions:SendEmail' :: Maybe ListManagementOptions
listManagementOptions = Maybe ListManagementOptions
a} :: SendEmail)

-- | A list of tags, in the form of name\/value pairs, to apply to an email
-- that you send using the @SendEmail@ operation. Tags correspond to
-- characteristics of the email that you define, so that you can publish
-- email sending events.
sendEmail_emailTags :: Lens.Lens' SendEmail (Prelude.Maybe [MessageTag])
sendEmail_emailTags :: (Maybe [MessageTag] -> f (Maybe [MessageTag]))
-> SendEmail -> f SendEmail
sendEmail_emailTags = (SendEmail -> Maybe [MessageTag])
-> (SendEmail -> Maybe [MessageTag] -> SendEmail)
-> Lens
     SendEmail SendEmail (Maybe [MessageTag]) (Maybe [MessageTag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe [MessageTag]
emailTags :: Maybe [MessageTag]
$sel:emailTags:SendEmail' :: SendEmail -> Maybe [MessageTag]
emailTags} -> Maybe [MessageTag]
emailTags) (\s :: SendEmail
s@SendEmail' {} Maybe [MessageTag]
a -> SendEmail
s {$sel:emailTags:SendEmail' :: Maybe [MessageTag]
emailTags = Maybe [MessageTag]
a} :: SendEmail) ((Maybe [MessageTag] -> f (Maybe [MessageTag]))
 -> SendEmail -> f SendEmail)
-> ((Maybe [MessageTag] -> f (Maybe [MessageTag]))
    -> Maybe [MessageTag] -> f (Maybe [MessageTag]))
-> (Maybe [MessageTag] -> f (Maybe [MessageTag]))
-> SendEmail
-> f SendEmail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [MessageTag] [MessageTag] [MessageTag] [MessageTag]
-> Iso
     (Maybe [MessageTag])
     (Maybe [MessageTag])
     (Maybe [MessageTag])
     (Maybe [MessageTag])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [MessageTag] [MessageTag] [MessageTag] [MessageTag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The address that you want bounce and complaint notifications to be sent
-- to.
sendEmail_feedbackForwardingEmailAddress :: Lens.Lens' SendEmail (Prelude.Maybe Prelude.Text)
sendEmail_feedbackForwardingEmailAddress :: (Maybe Text -> f (Maybe Text)) -> SendEmail -> f SendEmail
sendEmail_feedbackForwardingEmailAddress = (SendEmail -> Maybe Text)
-> (SendEmail -> Maybe Text -> SendEmail)
-> Lens SendEmail SendEmail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe Text
feedbackForwardingEmailAddress :: Maybe Text
$sel:feedbackForwardingEmailAddress:SendEmail' :: SendEmail -> Maybe Text
feedbackForwardingEmailAddress} -> Maybe Text
feedbackForwardingEmailAddress) (\s :: SendEmail
s@SendEmail' {} Maybe Text
a -> SendEmail
s {$sel:feedbackForwardingEmailAddress:SendEmail' :: Maybe Text
feedbackForwardingEmailAddress = Maybe Text
a} :: SendEmail)

-- | This parameter is used only for sending authorization. It is the ARN of
-- the identity that is associated with the sending authorization policy
-- that permits you to use the email address specified in the
-- @FeedbackForwardingEmailAddress@ parameter.
--
-- For example, if the owner of example.com (which has ARN
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com) attaches a
-- policy to it that authorizes you to use feedback\@example.com, then you
-- would specify the @FeedbackForwardingEmailAddressIdentityArn@ to be
-- arn:aws:ses:us-east-1:123456789012:identity\/example.com, and the
-- @FeedbackForwardingEmailAddress@ to be feedback\@example.com.
--
-- For more information about sending authorization, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
sendEmail_feedbackForwardingEmailAddressIdentityArn :: Lens.Lens' SendEmail (Prelude.Maybe Prelude.Text)
sendEmail_feedbackForwardingEmailAddressIdentityArn :: (Maybe Text -> f (Maybe Text)) -> SendEmail -> f SendEmail
sendEmail_feedbackForwardingEmailAddressIdentityArn = (SendEmail -> Maybe Text)
-> (SendEmail -> Maybe Text -> SendEmail)
-> Lens SendEmail SendEmail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe Text
feedbackForwardingEmailAddressIdentityArn :: Maybe Text
$sel:feedbackForwardingEmailAddressIdentityArn:SendEmail' :: SendEmail -> Maybe Text
feedbackForwardingEmailAddressIdentityArn} -> Maybe Text
feedbackForwardingEmailAddressIdentityArn) (\s :: SendEmail
s@SendEmail' {} Maybe Text
a -> SendEmail
s {$sel:feedbackForwardingEmailAddressIdentityArn:SendEmail' :: Maybe Text
feedbackForwardingEmailAddressIdentityArn = Maybe Text
a} :: SendEmail)

-- | The \"Reply-to\" email addresses for the message. When the recipient
-- replies to the message, each Reply-to address receives the reply.
sendEmail_replyToAddresses :: Lens.Lens' SendEmail (Prelude.Maybe [Prelude.Text])
sendEmail_replyToAddresses :: (Maybe [Text] -> f (Maybe [Text])) -> SendEmail -> f SendEmail
sendEmail_replyToAddresses = (SendEmail -> Maybe [Text])
-> (SendEmail -> Maybe [Text] -> SendEmail)
-> Lens SendEmail SendEmail (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {Maybe [Text]
replyToAddresses :: Maybe [Text]
$sel:replyToAddresses:SendEmail' :: SendEmail -> Maybe [Text]
replyToAddresses} -> Maybe [Text]
replyToAddresses) (\s :: SendEmail
s@SendEmail' {} Maybe [Text]
a -> SendEmail
s {$sel:replyToAddresses:SendEmail' :: Maybe [Text]
replyToAddresses = Maybe [Text]
a} :: SendEmail) ((Maybe [Text] -> f (Maybe [Text])) -> SendEmail -> f SendEmail)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> SendEmail
-> f SendEmail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | An object that contains the body of the message. You can send either a
-- Simple message Raw message or a template Message.
sendEmail_content :: Lens.Lens' SendEmail EmailContent
sendEmail_content :: (EmailContent -> f EmailContent) -> SendEmail -> f SendEmail
sendEmail_content = (SendEmail -> EmailContent)
-> (SendEmail -> EmailContent -> SendEmail)
-> Lens SendEmail SendEmail EmailContent EmailContent
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmail' {EmailContent
content :: EmailContent
$sel:content:SendEmail' :: SendEmail -> EmailContent
content} -> EmailContent
content) (\s :: SendEmail
s@SendEmail' {} EmailContent
a -> SendEmail
s {$sel:content:SendEmail' :: EmailContent
content = EmailContent
a} :: SendEmail)

instance Core.AWSRequest SendEmail where
  type AWSResponse SendEmail = SendEmailResponse
  request :: SendEmail -> Request SendEmail
request = Service -> SendEmail -> Request SendEmail
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy SendEmail
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SendEmail)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse SendEmail))
-> Logger
-> Service
-> Proxy SendEmail
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SendEmail)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text -> Int -> SendEmailResponse
SendEmailResponse'
            (Maybe Text -> Int -> SendEmailResponse)
-> Either String (Maybe Text)
-> Either String (Int -> SendEmailResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"MessageId")
            Either String (Int -> SendEmailResponse)
-> Either String Int -> Either String SendEmailResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable SendEmail

instance Prelude.NFData SendEmail

instance Core.ToHeaders SendEmail where
  toHeaders :: SendEmail -> ResponseHeaders
toHeaders =
    ResponseHeaders -> SendEmail -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON SendEmail where
  toJSON :: SendEmail -> Value
toJSON SendEmail' {Maybe [Text]
Maybe [MessageTag]
Maybe Text
Maybe Destination
Maybe ListManagementOptions
EmailContent
content :: EmailContent
replyToAddresses :: Maybe [Text]
feedbackForwardingEmailAddressIdentityArn :: Maybe Text
feedbackForwardingEmailAddress :: Maybe Text
emailTags :: Maybe [MessageTag]
listManagementOptions :: Maybe ListManagementOptions
configurationSetName :: Maybe Text
fromEmailAddressIdentityArn :: Maybe Text
destination :: Maybe Destination
fromEmailAddress :: Maybe Text
$sel:content:SendEmail' :: SendEmail -> EmailContent
$sel:replyToAddresses:SendEmail' :: SendEmail -> Maybe [Text]
$sel:feedbackForwardingEmailAddressIdentityArn:SendEmail' :: SendEmail -> Maybe Text
$sel:feedbackForwardingEmailAddress:SendEmail' :: SendEmail -> Maybe Text
$sel:emailTags:SendEmail' :: SendEmail -> Maybe [MessageTag]
$sel:listManagementOptions:SendEmail' :: SendEmail -> Maybe ListManagementOptions
$sel:configurationSetName:SendEmail' :: SendEmail -> Maybe Text
$sel:fromEmailAddressIdentityArn:SendEmail' :: SendEmail -> Maybe Text
$sel:destination:SendEmail' :: SendEmail -> Maybe Destination
$sel:fromEmailAddress:SendEmail' :: SendEmail -> Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"FromEmailAddress" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
fromEmailAddress,
            (Text
"Destination" Text -> Destination -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Destination -> Pair) -> Maybe Destination -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Destination
destination,
            (Text
"FromEmailAddressIdentityArn" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
fromEmailAddressIdentityArn,
            (Text
"ConfigurationSetName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
configurationSetName,
            (Text
"ListManagementOptions" Text -> ListManagementOptions -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ListManagementOptions -> Pair)
-> Maybe ListManagementOptions -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ListManagementOptions
listManagementOptions,
            (Text
"EmailTags" Text -> [MessageTag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([MessageTag] -> Pair) -> Maybe [MessageTag] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [MessageTag]
emailTags,
            (Text
"FeedbackForwardingEmailAddress" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
feedbackForwardingEmailAddress,
            (Text
"FeedbackForwardingEmailAddressIdentityArn" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
feedbackForwardingEmailAddressIdentityArn,
            (Text
"ReplyToAddresses" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
replyToAddresses,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"Content" Text -> EmailContent -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= EmailContent
content)
          ]
      )

instance Core.ToPath SendEmail where
  toPath :: SendEmail -> ByteString
toPath = ByteString -> SendEmail -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/v2/email/outbound-emails"

instance Core.ToQuery SendEmail where
  toQuery :: SendEmail -> QueryString
toQuery = QueryString -> SendEmail -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | A unique message ID that you receive when an email is accepted for
-- sending.
--
-- /See:/ 'newSendEmailResponse' smart constructor.
data SendEmailResponse = SendEmailResponse'
  { -- | A unique identifier for the message that is generated when the message
    -- is accepted.
    --
    -- It\'s possible for Amazon SES to accept a message without sending it.
    -- This can happen when the message that you\'re trying to send has an
    -- attachment contains a virus, or when you send a templated email that
    -- contains invalid personalization content, for example.
    SendEmailResponse -> Maybe Text
messageId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    SendEmailResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (SendEmailResponse -> SendEmailResponse -> Bool
(SendEmailResponse -> SendEmailResponse -> Bool)
-> (SendEmailResponse -> SendEmailResponse -> Bool)
-> Eq SendEmailResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SendEmailResponse -> SendEmailResponse -> Bool
$c/= :: SendEmailResponse -> SendEmailResponse -> Bool
== :: SendEmailResponse -> SendEmailResponse -> Bool
$c== :: SendEmailResponse -> SendEmailResponse -> Bool
Prelude.Eq, ReadPrec [SendEmailResponse]
ReadPrec SendEmailResponse
Int -> ReadS SendEmailResponse
ReadS [SendEmailResponse]
(Int -> ReadS SendEmailResponse)
-> ReadS [SendEmailResponse]
-> ReadPrec SendEmailResponse
-> ReadPrec [SendEmailResponse]
-> Read SendEmailResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SendEmailResponse]
$creadListPrec :: ReadPrec [SendEmailResponse]
readPrec :: ReadPrec SendEmailResponse
$creadPrec :: ReadPrec SendEmailResponse
readList :: ReadS [SendEmailResponse]
$creadList :: ReadS [SendEmailResponse]
readsPrec :: Int -> ReadS SendEmailResponse
$creadsPrec :: Int -> ReadS SendEmailResponse
Prelude.Read, Int -> SendEmailResponse -> ShowS
[SendEmailResponse] -> ShowS
SendEmailResponse -> String
(Int -> SendEmailResponse -> ShowS)
-> (SendEmailResponse -> String)
-> ([SendEmailResponse] -> ShowS)
-> Show SendEmailResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SendEmailResponse] -> ShowS
$cshowList :: [SendEmailResponse] -> ShowS
show :: SendEmailResponse -> String
$cshow :: SendEmailResponse -> String
showsPrec :: Int -> SendEmailResponse -> ShowS
$cshowsPrec :: Int -> SendEmailResponse -> ShowS
Prelude.Show, (forall x. SendEmailResponse -> Rep SendEmailResponse x)
-> (forall x. Rep SendEmailResponse x -> SendEmailResponse)
-> Generic SendEmailResponse
forall x. Rep SendEmailResponse x -> SendEmailResponse
forall x. SendEmailResponse -> Rep SendEmailResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SendEmailResponse x -> SendEmailResponse
$cfrom :: forall x. SendEmailResponse -> Rep SendEmailResponse x
Prelude.Generic)

-- |
-- Create a value of 'SendEmailResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'messageId', 'sendEmailResponse_messageId' - A unique identifier for the message that is generated when the message
-- is accepted.
--
-- It\'s possible for Amazon SES to accept a message without sending it.
-- This can happen when the message that you\'re trying to send has an
-- attachment contains a virus, or when you send a templated email that
-- contains invalid personalization content, for example.
--
-- 'httpStatus', 'sendEmailResponse_httpStatus' - The response's http status code.
newSendEmailResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SendEmailResponse
newSendEmailResponse :: Int -> SendEmailResponse
newSendEmailResponse Int
pHttpStatus_ =
  SendEmailResponse' :: Maybe Text -> Int -> SendEmailResponse
SendEmailResponse'
    { $sel:messageId:SendEmailResponse' :: Maybe Text
messageId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SendEmailResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A unique identifier for the message that is generated when the message
-- is accepted.
--
-- It\'s possible for Amazon SES to accept a message without sending it.
-- This can happen when the message that you\'re trying to send has an
-- attachment contains a virus, or when you send a templated email that
-- contains invalid personalization content, for example.
sendEmailResponse_messageId :: Lens.Lens' SendEmailResponse (Prelude.Maybe Prelude.Text)
sendEmailResponse_messageId :: (Maybe Text -> f (Maybe Text))
-> SendEmailResponse -> f SendEmailResponse
sendEmailResponse_messageId = (SendEmailResponse -> Maybe Text)
-> (SendEmailResponse -> Maybe Text -> SendEmailResponse)
-> Lens
     SendEmailResponse SendEmailResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmailResponse' {Maybe Text
messageId :: Maybe Text
$sel:messageId:SendEmailResponse' :: SendEmailResponse -> Maybe Text
messageId} -> Maybe Text
messageId) (\s :: SendEmailResponse
s@SendEmailResponse' {} Maybe Text
a -> SendEmailResponse
s {$sel:messageId:SendEmailResponse' :: Maybe Text
messageId = Maybe Text
a} :: SendEmailResponse)

-- | The response's http status code.
sendEmailResponse_httpStatus :: Lens.Lens' SendEmailResponse Prelude.Int
sendEmailResponse_httpStatus :: (Int -> f Int) -> SendEmailResponse -> f SendEmailResponse
sendEmailResponse_httpStatus = (SendEmailResponse -> Int)
-> (SendEmailResponse -> Int -> SendEmailResponse)
-> Lens SendEmailResponse SendEmailResponse Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendEmailResponse' {Int
httpStatus :: Int
$sel:httpStatus:SendEmailResponse' :: SendEmailResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: SendEmailResponse
s@SendEmailResponse' {} Int
a -> SendEmailResponse
s {$sel:httpStatus:SendEmailResponse' :: Int
httpStatus = Int
a} :: SendEmailResponse)

instance Prelude.NFData SendEmailResponse