{-# 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.SES.ListIdentities
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns a list containing all of the identities (email addresses and
-- domains) for your AWS account in the current AWS Region, regardless of
-- verification status.
--
-- You can execute this operation no more than once per second.
--
-- This operation returns paginated results.
module Amazonka.SES.ListIdentities
  ( -- * Creating a Request
    ListIdentities (..),
    newListIdentities,

    -- * Request Lenses
    listIdentities_identityType,
    listIdentities_maxItems,
    listIdentities_nextToken,

    -- * Destructuring the Response
    ListIdentitiesResponse (..),
    newListIdentitiesResponse,

    -- * Response Lenses
    listIdentitiesResponse_nextToken,
    listIdentitiesResponse_httpStatus,
    listIdentitiesResponse_identities,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SES.Types

-- | Represents a request to return a list of all identities (email addresses
-- and domains) that you have attempted to verify under your AWS account,
-- regardless of verification status.
--
-- /See:/ 'newListIdentities' smart constructor.
data ListIdentities = ListIdentities'
  { -- | The type of the identities to list. Possible values are \"EmailAddress\"
    -- and \"Domain\". If this parameter is omitted, then all identities will
    -- be listed.
    ListIdentities -> Maybe IdentityType
identityType :: Prelude.Maybe IdentityType,
    -- | The maximum number of identities per page. Possible values are 1-1000
    -- inclusive.
    ListIdentities -> Maybe Int
maxItems :: Prelude.Maybe Prelude.Int,
    -- | The token to use for pagination.
    ListIdentities -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListIdentities -> ListIdentities -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListIdentities -> ListIdentities -> Bool
$c/= :: ListIdentities -> ListIdentities -> Bool
== :: ListIdentities -> ListIdentities -> Bool
$c== :: ListIdentities -> ListIdentities -> Bool
Prelude.Eq, ReadPrec [ListIdentities]
ReadPrec ListIdentities
Int -> ReadS ListIdentities
ReadS [ListIdentities]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListIdentities]
$creadListPrec :: ReadPrec [ListIdentities]
readPrec :: ReadPrec ListIdentities
$creadPrec :: ReadPrec ListIdentities
readList :: ReadS [ListIdentities]
$creadList :: ReadS [ListIdentities]
readsPrec :: Int -> ReadS ListIdentities
$creadsPrec :: Int -> ReadS ListIdentities
Prelude.Read, Int -> ListIdentities -> ShowS
[ListIdentities] -> ShowS
ListIdentities -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListIdentities] -> ShowS
$cshowList :: [ListIdentities] -> ShowS
show :: ListIdentities -> String
$cshow :: ListIdentities -> String
showsPrec :: Int -> ListIdentities -> ShowS
$cshowsPrec :: Int -> ListIdentities -> ShowS
Prelude.Show, forall x. Rep ListIdentities x -> ListIdentities
forall x. ListIdentities -> Rep ListIdentities x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListIdentities x -> ListIdentities
$cfrom :: forall x. ListIdentities -> Rep ListIdentities x
Prelude.Generic)

-- |
-- Create a value of 'ListIdentities' 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:
--
-- 'identityType', 'listIdentities_identityType' - The type of the identities to list. Possible values are \"EmailAddress\"
-- and \"Domain\". If this parameter is omitted, then all identities will
-- be listed.
--
-- 'maxItems', 'listIdentities_maxItems' - The maximum number of identities per page. Possible values are 1-1000
-- inclusive.
--
-- 'nextToken', 'listIdentities_nextToken' - The token to use for pagination.
newListIdentities ::
  ListIdentities
newListIdentities :: ListIdentities
newListIdentities =
  ListIdentities'
    { $sel:identityType:ListIdentities' :: Maybe IdentityType
identityType = forall a. Maybe a
Prelude.Nothing,
      $sel:maxItems:ListIdentities' :: Maybe Int
maxItems = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListIdentities' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The type of the identities to list. Possible values are \"EmailAddress\"
-- and \"Domain\". If this parameter is omitted, then all identities will
-- be listed.
listIdentities_identityType :: Lens.Lens' ListIdentities (Prelude.Maybe IdentityType)
listIdentities_identityType :: Lens' ListIdentities (Maybe IdentityType)
listIdentities_identityType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListIdentities' {Maybe IdentityType
identityType :: Maybe IdentityType
$sel:identityType:ListIdentities' :: ListIdentities -> Maybe IdentityType
identityType} -> Maybe IdentityType
identityType) (\s :: ListIdentities
s@ListIdentities' {} Maybe IdentityType
a -> ListIdentities
s {$sel:identityType:ListIdentities' :: Maybe IdentityType
identityType = Maybe IdentityType
a} :: ListIdentities)

-- | The maximum number of identities per page. Possible values are 1-1000
-- inclusive.
listIdentities_maxItems :: Lens.Lens' ListIdentities (Prelude.Maybe Prelude.Int)
listIdentities_maxItems :: Lens' ListIdentities (Maybe Int)
listIdentities_maxItems = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListIdentities' {Maybe Int
maxItems :: Maybe Int
$sel:maxItems:ListIdentities' :: ListIdentities -> Maybe Int
maxItems} -> Maybe Int
maxItems) (\s :: ListIdentities
s@ListIdentities' {} Maybe Int
a -> ListIdentities
s {$sel:maxItems:ListIdentities' :: Maybe Int
maxItems = Maybe Int
a} :: ListIdentities)

-- | The token to use for pagination.
listIdentities_nextToken :: Lens.Lens' ListIdentities (Prelude.Maybe Prelude.Text)
listIdentities_nextToken :: Lens' ListIdentities (Maybe Text)
listIdentities_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListIdentities' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListIdentities' :: ListIdentities -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListIdentities
s@ListIdentities' {} Maybe Text
a -> ListIdentities
s {$sel:nextToken:ListIdentities' :: Maybe Text
nextToken = Maybe Text
a} :: ListIdentities)

instance Core.AWSPager ListIdentities where
  page :: ListIdentities
-> AWSResponse ListIdentities -> Maybe ListIdentities
page ListIdentities
rq AWSResponse ListIdentities
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListIdentities
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListIdentitiesResponse (Maybe Text)
listIdentitiesResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        (AWSResponse ListIdentities
rs forall s a. s -> Getting a s a -> a
Lens.^. Lens' ListIdentitiesResponse [Text]
listIdentitiesResponse_identities) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListIdentities
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListIdentities (Maybe Text)
listIdentities_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListIdentities
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListIdentitiesResponse (Maybe Text)
listIdentitiesResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListIdentities where
  type
    AWSResponse ListIdentities =
      ListIdentitiesResponse
  request :: (Service -> Service) -> ListIdentities -> Request ListIdentities
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListIdentities
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListIdentities)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"ListIdentitiesResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe Text -> Int -> [Text] -> ListIdentitiesResponse
ListIdentitiesResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"NextToken")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Identities"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member"
                        )
      )

instance Prelude.Hashable ListIdentities where
  hashWithSalt :: Int -> ListIdentities -> Int
hashWithSalt Int
_salt ListIdentities' {Maybe Int
Maybe Text
Maybe IdentityType
nextToken :: Maybe Text
maxItems :: Maybe Int
identityType :: Maybe IdentityType
$sel:nextToken:ListIdentities' :: ListIdentities -> Maybe Text
$sel:maxItems:ListIdentities' :: ListIdentities -> Maybe Int
$sel:identityType:ListIdentities' :: ListIdentities -> Maybe IdentityType
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe IdentityType
identityType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
maxItems
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData ListIdentities where
  rnf :: ListIdentities -> ()
rnf ListIdentities' {Maybe Int
Maybe Text
Maybe IdentityType
nextToken :: Maybe Text
maxItems :: Maybe Int
identityType :: Maybe IdentityType
$sel:nextToken:ListIdentities' :: ListIdentities -> Maybe Text
$sel:maxItems:ListIdentities' :: ListIdentities -> Maybe Int
$sel:identityType:ListIdentities' :: ListIdentities -> Maybe IdentityType
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe IdentityType
identityType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxItems
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

instance Data.ToHeaders ListIdentities where
  toHeaders :: ListIdentities -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToPath ListIdentities where
  toPath :: ListIdentities -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery ListIdentities where
  toQuery :: ListIdentities -> QueryString
toQuery ListIdentities' {Maybe Int
Maybe Text
Maybe IdentityType
nextToken :: Maybe Text
maxItems :: Maybe Int
identityType :: Maybe IdentityType
$sel:nextToken:ListIdentities' :: ListIdentities -> Maybe Text
$sel:maxItems:ListIdentities' :: ListIdentities -> Maybe Int
$sel:identityType:ListIdentities' :: ListIdentities -> Maybe IdentityType
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ListIdentities" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2010-12-01" :: Prelude.ByteString),
        ByteString
"IdentityType" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe IdentityType
identityType,
        ByteString
"MaxItems" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
maxItems,
        ByteString
"NextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken
      ]

-- | A list of all identities that you have attempted to verify under your
-- AWS account, regardless of verification status.
--
-- /See:/ 'newListIdentitiesResponse' smart constructor.
data ListIdentitiesResponse = ListIdentitiesResponse'
  { -- | The token used for pagination.
    ListIdentitiesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListIdentitiesResponse -> Int
httpStatus :: Prelude.Int,
    -- | A list of identities.
    ListIdentitiesResponse -> [Text]
identities :: [Prelude.Text]
  }
  deriving (ListIdentitiesResponse -> ListIdentitiesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListIdentitiesResponse -> ListIdentitiesResponse -> Bool
$c/= :: ListIdentitiesResponse -> ListIdentitiesResponse -> Bool
== :: ListIdentitiesResponse -> ListIdentitiesResponse -> Bool
$c== :: ListIdentitiesResponse -> ListIdentitiesResponse -> Bool
Prelude.Eq, ReadPrec [ListIdentitiesResponse]
ReadPrec ListIdentitiesResponse
Int -> ReadS ListIdentitiesResponse
ReadS [ListIdentitiesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListIdentitiesResponse]
$creadListPrec :: ReadPrec [ListIdentitiesResponse]
readPrec :: ReadPrec ListIdentitiesResponse
$creadPrec :: ReadPrec ListIdentitiesResponse
readList :: ReadS [ListIdentitiesResponse]
$creadList :: ReadS [ListIdentitiesResponse]
readsPrec :: Int -> ReadS ListIdentitiesResponse
$creadsPrec :: Int -> ReadS ListIdentitiesResponse
Prelude.Read, Int -> ListIdentitiesResponse -> ShowS
[ListIdentitiesResponse] -> ShowS
ListIdentitiesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListIdentitiesResponse] -> ShowS
$cshowList :: [ListIdentitiesResponse] -> ShowS
show :: ListIdentitiesResponse -> String
$cshow :: ListIdentitiesResponse -> String
showsPrec :: Int -> ListIdentitiesResponse -> ShowS
$cshowsPrec :: Int -> ListIdentitiesResponse -> ShowS
Prelude.Show, forall x. Rep ListIdentitiesResponse x -> ListIdentitiesResponse
forall x. ListIdentitiesResponse -> Rep ListIdentitiesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListIdentitiesResponse x -> ListIdentitiesResponse
$cfrom :: forall x. ListIdentitiesResponse -> Rep ListIdentitiesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListIdentitiesResponse' 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:
--
-- 'nextToken', 'listIdentitiesResponse_nextToken' - The token used for pagination.
--
-- 'httpStatus', 'listIdentitiesResponse_httpStatus' - The response's http status code.
--
-- 'identities', 'listIdentitiesResponse_identities' - A list of identities.
newListIdentitiesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListIdentitiesResponse
newListIdentitiesResponse :: Int -> ListIdentitiesResponse
newListIdentitiesResponse Int
pHttpStatus_ =
  ListIdentitiesResponse'
    { $sel:nextToken:ListIdentitiesResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListIdentitiesResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:identities:ListIdentitiesResponse' :: [Text]
identities = forall a. Monoid a => a
Prelude.mempty
    }

-- | The token used for pagination.
listIdentitiesResponse_nextToken :: Lens.Lens' ListIdentitiesResponse (Prelude.Maybe Prelude.Text)
listIdentitiesResponse_nextToken :: Lens' ListIdentitiesResponse (Maybe Text)
listIdentitiesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListIdentitiesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListIdentitiesResponse' :: ListIdentitiesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListIdentitiesResponse
s@ListIdentitiesResponse' {} Maybe Text
a -> ListIdentitiesResponse
s {$sel:nextToken:ListIdentitiesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListIdentitiesResponse)

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

-- | A list of identities.
listIdentitiesResponse_identities :: Lens.Lens' ListIdentitiesResponse [Prelude.Text]
listIdentitiesResponse_identities :: Lens' ListIdentitiesResponse [Text]
listIdentitiesResponse_identities = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListIdentitiesResponse' {[Text]
identities :: [Text]
$sel:identities:ListIdentitiesResponse' :: ListIdentitiesResponse -> [Text]
identities} -> [Text]
identities) (\s :: ListIdentitiesResponse
s@ListIdentitiesResponse' {} [Text]
a -> ListIdentitiesResponse
s {$sel:identities:ListIdentitiesResponse' :: [Text]
identities = [Text]
a} :: ListIdentitiesResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Prelude.NFData ListIdentitiesResponse where
  rnf :: ListIdentitiesResponse -> ()
rnf ListIdentitiesResponse' {Int
[Text]
Maybe Text
identities :: [Text]
httpStatus :: Int
nextToken :: Maybe Text
$sel:identities:ListIdentitiesResponse' :: ListIdentitiesResponse -> [Text]
$sel:httpStatus:ListIdentitiesResponse' :: ListIdentitiesResponse -> Int
$sel:nextToken:ListIdentitiesResponse' :: ListIdentitiesResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
identities