{-# 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.Inspector2.ListDelegatedAdminAccounts
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists information about the Amazon Inspector delegated administrator of
-- your organization.
--
-- This operation returns paginated results.
module Amazonka.Inspector2.ListDelegatedAdminAccounts
  ( -- * Creating a Request
    ListDelegatedAdminAccounts (..),
    newListDelegatedAdminAccounts,

    -- * Request Lenses
    listDelegatedAdminAccounts_maxResults,
    listDelegatedAdminAccounts_nextToken,

    -- * Destructuring the Response
    ListDelegatedAdminAccountsResponse (..),
    newListDelegatedAdminAccountsResponse,

    -- * Response Lenses
    listDelegatedAdminAccountsResponse_delegatedAdminAccounts,
    listDelegatedAdminAccountsResponse_nextToken,
    listDelegatedAdminAccountsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListDelegatedAdminAccounts' smart constructor.
data ListDelegatedAdminAccounts = ListDelegatedAdminAccounts'
  { -- | The maximum number of results to return in the response.
    ListDelegatedAdminAccounts -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | A token to use for paginating results that are returned in the response.
    -- Set the value of this parameter to null for the first request to a list
    -- action. For subsequent calls, use the @NextToken@ value returned from
    -- the previous request to continue listing results after the first page.
    ListDelegatedAdminAccounts -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListDelegatedAdminAccounts -> ListDelegatedAdminAccounts -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListDelegatedAdminAccounts -> ListDelegatedAdminAccounts -> Bool
$c/= :: ListDelegatedAdminAccounts -> ListDelegatedAdminAccounts -> Bool
== :: ListDelegatedAdminAccounts -> ListDelegatedAdminAccounts -> Bool
$c== :: ListDelegatedAdminAccounts -> ListDelegatedAdminAccounts -> Bool
Prelude.Eq, ReadPrec [ListDelegatedAdminAccounts]
ReadPrec ListDelegatedAdminAccounts
Int -> ReadS ListDelegatedAdminAccounts
ReadS [ListDelegatedAdminAccounts]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListDelegatedAdminAccounts]
$creadListPrec :: ReadPrec [ListDelegatedAdminAccounts]
readPrec :: ReadPrec ListDelegatedAdminAccounts
$creadPrec :: ReadPrec ListDelegatedAdminAccounts
readList :: ReadS [ListDelegatedAdminAccounts]
$creadList :: ReadS [ListDelegatedAdminAccounts]
readsPrec :: Int -> ReadS ListDelegatedAdminAccounts
$creadsPrec :: Int -> ReadS ListDelegatedAdminAccounts
Prelude.Read, Int -> ListDelegatedAdminAccounts -> ShowS
[ListDelegatedAdminAccounts] -> ShowS
ListDelegatedAdminAccounts -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListDelegatedAdminAccounts] -> ShowS
$cshowList :: [ListDelegatedAdminAccounts] -> ShowS
show :: ListDelegatedAdminAccounts -> String
$cshow :: ListDelegatedAdminAccounts -> String
showsPrec :: Int -> ListDelegatedAdminAccounts -> ShowS
$cshowsPrec :: Int -> ListDelegatedAdminAccounts -> ShowS
Prelude.Show, forall x.
Rep ListDelegatedAdminAccounts x -> ListDelegatedAdminAccounts
forall x.
ListDelegatedAdminAccounts -> Rep ListDelegatedAdminAccounts x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListDelegatedAdminAccounts x -> ListDelegatedAdminAccounts
$cfrom :: forall x.
ListDelegatedAdminAccounts -> Rep ListDelegatedAdminAccounts x
Prelude.Generic)

-- |
-- Create a value of 'ListDelegatedAdminAccounts' 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:
--
-- 'maxResults', 'listDelegatedAdminAccounts_maxResults' - The maximum number of results to return in the response.
--
-- 'nextToken', 'listDelegatedAdminAccounts_nextToken' - A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
newListDelegatedAdminAccounts ::
  ListDelegatedAdminAccounts
newListDelegatedAdminAccounts :: ListDelegatedAdminAccounts
newListDelegatedAdminAccounts =
  ListDelegatedAdminAccounts'
    { $sel:maxResults:ListDelegatedAdminAccounts' :: Maybe Natural
maxResults =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListDelegatedAdminAccounts' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The maximum number of results to return in the response.
listDelegatedAdminAccounts_maxResults :: Lens.Lens' ListDelegatedAdminAccounts (Prelude.Maybe Prelude.Natural)
listDelegatedAdminAccounts_maxResults :: Lens' ListDelegatedAdminAccounts (Maybe Natural)
listDelegatedAdminAccounts_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDelegatedAdminAccounts' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListDelegatedAdminAccounts
s@ListDelegatedAdminAccounts' {} Maybe Natural
a -> ListDelegatedAdminAccounts
s {$sel:maxResults:ListDelegatedAdminAccounts' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListDelegatedAdminAccounts)

-- | A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
listDelegatedAdminAccounts_nextToken :: Lens.Lens' ListDelegatedAdminAccounts (Prelude.Maybe Prelude.Text)
listDelegatedAdminAccounts_nextToken :: Lens' ListDelegatedAdminAccounts (Maybe Text)
listDelegatedAdminAccounts_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDelegatedAdminAccounts' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListDelegatedAdminAccounts
s@ListDelegatedAdminAccounts' {} Maybe Text
a -> ListDelegatedAdminAccounts
s {$sel:nextToken:ListDelegatedAdminAccounts' :: Maybe Text
nextToken = Maybe Text
a} :: ListDelegatedAdminAccounts)

instance Core.AWSPager ListDelegatedAdminAccounts where
  page :: ListDelegatedAdminAccounts
-> AWSResponse ListDelegatedAdminAccounts
-> Maybe ListDelegatedAdminAccounts
page ListDelegatedAdminAccounts
rq AWSResponse ListDelegatedAdminAccounts
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListDelegatedAdminAccounts
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListDelegatedAdminAccountsResponse (Maybe Text)
listDelegatedAdminAccountsResponse_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 ListDelegatedAdminAccounts
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListDelegatedAdminAccountsResponse (Maybe [DelegatedAdminAccount])
listDelegatedAdminAccountsResponse_delegatedAdminAccounts
            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
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListDelegatedAdminAccounts
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListDelegatedAdminAccounts (Maybe Text)
listDelegatedAdminAccounts_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListDelegatedAdminAccounts
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListDelegatedAdminAccountsResponse (Maybe Text)
listDelegatedAdminAccountsResponse_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 ListDelegatedAdminAccounts where
  type
    AWSResponse ListDelegatedAdminAccounts =
      ListDelegatedAdminAccountsResponse
  request :: (Service -> Service)
-> ListDelegatedAdminAccounts -> Request ListDelegatedAdminAccounts
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListDelegatedAdminAccounts
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListDelegatedAdminAccounts)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [DelegatedAdminAccount]
-> Maybe Text -> Int -> ListDelegatedAdminAccountsResponse
ListDelegatedAdminAccountsResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"delegatedAdminAccounts"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"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))
      )

instance Prelude.Hashable ListDelegatedAdminAccounts where
  hashWithSalt :: Int -> ListDelegatedAdminAccounts -> Int
hashWithSalt Int
_salt ListDelegatedAdminAccounts' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Text
$sel:maxResults:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData ListDelegatedAdminAccounts where
  rnf :: ListDelegatedAdminAccounts -> ()
rnf ListDelegatedAdminAccounts' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Text
$sel:maxResults:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Natural
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

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

instance Data.ToJSON ListDelegatedAdminAccounts where
  toJSON :: ListDelegatedAdminAccounts -> Value
toJSON ListDelegatedAdminAccounts' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Text
$sel:maxResults:ListDelegatedAdminAccounts' :: ListDelegatedAdminAccounts -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"maxResults" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxResults,
            (Key
"nextToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken
          ]
      )

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

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

-- | /See:/ 'newListDelegatedAdminAccountsResponse' smart constructor.
data ListDelegatedAdminAccountsResponse = ListDelegatedAdminAccountsResponse'
  { -- | Details of the Amazon Inspector delegated administrator of your
    -- organization.
    ListDelegatedAdminAccountsResponse -> Maybe [DelegatedAdminAccount]
delegatedAdminAccounts :: Prelude.Maybe [DelegatedAdminAccount],
    -- | A token to use for paginating results that are returned in the response.
    -- Set the value of this parameter to null for the first request to a list
    -- action. For subsequent calls, use the @NextToken@ value returned from
    -- the previous request to continue listing results after the first page.
    ListDelegatedAdminAccountsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListDelegatedAdminAccountsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListDelegatedAdminAccountsResponse
-> ListDelegatedAdminAccountsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListDelegatedAdminAccountsResponse
-> ListDelegatedAdminAccountsResponse -> Bool
$c/= :: ListDelegatedAdminAccountsResponse
-> ListDelegatedAdminAccountsResponse -> Bool
== :: ListDelegatedAdminAccountsResponse
-> ListDelegatedAdminAccountsResponse -> Bool
$c== :: ListDelegatedAdminAccountsResponse
-> ListDelegatedAdminAccountsResponse -> Bool
Prelude.Eq, ReadPrec [ListDelegatedAdminAccountsResponse]
ReadPrec ListDelegatedAdminAccountsResponse
Int -> ReadS ListDelegatedAdminAccountsResponse
ReadS [ListDelegatedAdminAccountsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListDelegatedAdminAccountsResponse]
$creadListPrec :: ReadPrec [ListDelegatedAdminAccountsResponse]
readPrec :: ReadPrec ListDelegatedAdminAccountsResponse
$creadPrec :: ReadPrec ListDelegatedAdminAccountsResponse
readList :: ReadS [ListDelegatedAdminAccountsResponse]
$creadList :: ReadS [ListDelegatedAdminAccountsResponse]
readsPrec :: Int -> ReadS ListDelegatedAdminAccountsResponse
$creadsPrec :: Int -> ReadS ListDelegatedAdminAccountsResponse
Prelude.Read, Int -> ListDelegatedAdminAccountsResponse -> ShowS
[ListDelegatedAdminAccountsResponse] -> ShowS
ListDelegatedAdminAccountsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListDelegatedAdminAccountsResponse] -> ShowS
$cshowList :: [ListDelegatedAdminAccountsResponse] -> ShowS
show :: ListDelegatedAdminAccountsResponse -> String
$cshow :: ListDelegatedAdminAccountsResponse -> String
showsPrec :: Int -> ListDelegatedAdminAccountsResponse -> ShowS
$cshowsPrec :: Int -> ListDelegatedAdminAccountsResponse -> ShowS
Prelude.Show, forall x.
Rep ListDelegatedAdminAccountsResponse x
-> ListDelegatedAdminAccountsResponse
forall x.
ListDelegatedAdminAccountsResponse
-> Rep ListDelegatedAdminAccountsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListDelegatedAdminAccountsResponse x
-> ListDelegatedAdminAccountsResponse
$cfrom :: forall x.
ListDelegatedAdminAccountsResponse
-> Rep ListDelegatedAdminAccountsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListDelegatedAdminAccountsResponse' 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:
--
-- 'delegatedAdminAccounts', 'listDelegatedAdminAccountsResponse_delegatedAdminAccounts' - Details of the Amazon Inspector delegated administrator of your
-- organization.
--
-- 'nextToken', 'listDelegatedAdminAccountsResponse_nextToken' - A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
--
-- 'httpStatus', 'listDelegatedAdminAccountsResponse_httpStatus' - The response's http status code.
newListDelegatedAdminAccountsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListDelegatedAdminAccountsResponse
newListDelegatedAdminAccountsResponse :: Int -> ListDelegatedAdminAccountsResponse
newListDelegatedAdminAccountsResponse Int
pHttpStatus_ =
  ListDelegatedAdminAccountsResponse'
    { $sel:delegatedAdminAccounts:ListDelegatedAdminAccountsResponse' :: Maybe [DelegatedAdminAccount]
delegatedAdminAccounts =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListDelegatedAdminAccountsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListDelegatedAdminAccountsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Details of the Amazon Inspector delegated administrator of your
-- organization.
listDelegatedAdminAccountsResponse_delegatedAdminAccounts :: Lens.Lens' ListDelegatedAdminAccountsResponse (Prelude.Maybe [DelegatedAdminAccount])
listDelegatedAdminAccountsResponse_delegatedAdminAccounts :: Lens'
  ListDelegatedAdminAccountsResponse (Maybe [DelegatedAdminAccount])
listDelegatedAdminAccountsResponse_delegatedAdminAccounts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDelegatedAdminAccountsResponse' {Maybe [DelegatedAdminAccount]
delegatedAdminAccounts :: Maybe [DelegatedAdminAccount]
$sel:delegatedAdminAccounts:ListDelegatedAdminAccountsResponse' :: ListDelegatedAdminAccountsResponse -> Maybe [DelegatedAdminAccount]
delegatedAdminAccounts} -> Maybe [DelegatedAdminAccount]
delegatedAdminAccounts) (\s :: ListDelegatedAdminAccountsResponse
s@ListDelegatedAdminAccountsResponse' {} Maybe [DelegatedAdminAccount]
a -> ListDelegatedAdminAccountsResponse
s {$sel:delegatedAdminAccounts:ListDelegatedAdminAccountsResponse' :: Maybe [DelegatedAdminAccount]
delegatedAdminAccounts = Maybe [DelegatedAdminAccount]
a} :: ListDelegatedAdminAccountsResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
listDelegatedAdminAccountsResponse_nextToken :: Lens.Lens' ListDelegatedAdminAccountsResponse (Prelude.Maybe Prelude.Text)
listDelegatedAdminAccountsResponse_nextToken :: Lens' ListDelegatedAdminAccountsResponse (Maybe Text)
listDelegatedAdminAccountsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDelegatedAdminAccountsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListDelegatedAdminAccountsResponse' :: ListDelegatedAdminAccountsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListDelegatedAdminAccountsResponse
s@ListDelegatedAdminAccountsResponse' {} Maybe Text
a -> ListDelegatedAdminAccountsResponse
s {$sel:nextToken:ListDelegatedAdminAccountsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListDelegatedAdminAccountsResponse)

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

instance
  Prelude.NFData
    ListDelegatedAdminAccountsResponse
  where
  rnf :: ListDelegatedAdminAccountsResponse -> ()
rnf ListDelegatedAdminAccountsResponse' {Int
Maybe [DelegatedAdminAccount]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
delegatedAdminAccounts :: Maybe [DelegatedAdminAccount]
$sel:httpStatus:ListDelegatedAdminAccountsResponse' :: ListDelegatedAdminAccountsResponse -> Int
$sel:nextToken:ListDelegatedAdminAccountsResponse' :: ListDelegatedAdminAccountsResponse -> Maybe Text
$sel:delegatedAdminAccounts:ListDelegatedAdminAccountsResponse' :: ListDelegatedAdminAccountsResponse -> Maybe [DelegatedAdminAccount]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [DelegatedAdminAccount]
delegatedAdminAccounts
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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