{-# 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.Route53Resolver.ListResolverDnssecConfigs
-- 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 the configurations for DNSSEC validation that are associated with
-- the current Amazon Web Services account.
--
-- This operation returns paginated results.
module Amazonka.Route53Resolver.ListResolverDnssecConfigs
  ( -- * Creating a Request
    ListResolverDnssecConfigs (..),
    newListResolverDnssecConfigs,

    -- * Request Lenses
    listResolverDnssecConfigs_filters,
    listResolverDnssecConfigs_maxResults,
    listResolverDnssecConfigs_nextToken,

    -- * Destructuring the Response
    ListResolverDnssecConfigsResponse (..),
    newListResolverDnssecConfigsResponse,

    -- * Response Lenses
    listResolverDnssecConfigsResponse_nextToken,
    listResolverDnssecConfigsResponse_resolverDnssecConfigs,
    listResolverDnssecConfigsResponse_httpStatus,
  )
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.Route53Resolver.Types

-- | /See:/ 'newListResolverDnssecConfigs' smart constructor.
data ListResolverDnssecConfigs = ListResolverDnssecConfigs'
  { -- | An optional specification to return a subset of objects.
    ListResolverDnssecConfigs -> Maybe [Filter]
filters :: Prelude.Maybe [Filter],
    -- | /Optional/: An integer that specifies the maximum number of DNSSEC
    -- configuration results that you want Amazon Route 53 to return. If you
    -- don\'t specify a value for @MaxResults@, Route 53 returns up to 100
    -- configuration per page.
    ListResolverDnssecConfigs -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | (Optional) If the current Amazon Web Services account has more than
    -- @MaxResults@ DNSSEC configurations, use @NextToken@ to get the second
    -- and subsequent pages of results.
    --
    -- For the first @ListResolverDnssecConfigs@ request, omit this value.
    --
    -- For the second and subsequent requests, get the value of @NextToken@
    -- from the previous response and specify that value for @NextToken@ in the
    -- request.
    ListResolverDnssecConfigs -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListResolverDnssecConfigs -> ListResolverDnssecConfigs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListResolverDnssecConfigs -> ListResolverDnssecConfigs -> Bool
$c/= :: ListResolverDnssecConfigs -> ListResolverDnssecConfigs -> Bool
== :: ListResolverDnssecConfigs -> ListResolverDnssecConfigs -> Bool
$c== :: ListResolverDnssecConfigs -> ListResolverDnssecConfigs -> Bool
Prelude.Eq, ReadPrec [ListResolverDnssecConfigs]
ReadPrec ListResolverDnssecConfigs
Int -> ReadS ListResolverDnssecConfigs
ReadS [ListResolverDnssecConfigs]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListResolverDnssecConfigs]
$creadListPrec :: ReadPrec [ListResolverDnssecConfigs]
readPrec :: ReadPrec ListResolverDnssecConfigs
$creadPrec :: ReadPrec ListResolverDnssecConfigs
readList :: ReadS [ListResolverDnssecConfigs]
$creadList :: ReadS [ListResolverDnssecConfigs]
readsPrec :: Int -> ReadS ListResolverDnssecConfigs
$creadsPrec :: Int -> ReadS ListResolverDnssecConfigs
Prelude.Read, Int -> ListResolverDnssecConfigs -> ShowS
[ListResolverDnssecConfigs] -> ShowS
ListResolverDnssecConfigs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListResolverDnssecConfigs] -> ShowS
$cshowList :: [ListResolverDnssecConfigs] -> ShowS
show :: ListResolverDnssecConfigs -> String
$cshow :: ListResolverDnssecConfigs -> String
showsPrec :: Int -> ListResolverDnssecConfigs -> ShowS
$cshowsPrec :: Int -> ListResolverDnssecConfigs -> ShowS
Prelude.Show, forall x.
Rep ListResolverDnssecConfigs x -> ListResolverDnssecConfigs
forall x.
ListResolverDnssecConfigs -> Rep ListResolverDnssecConfigs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListResolverDnssecConfigs x -> ListResolverDnssecConfigs
$cfrom :: forall x.
ListResolverDnssecConfigs -> Rep ListResolverDnssecConfigs x
Prelude.Generic)

-- |
-- Create a value of 'ListResolverDnssecConfigs' 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:
--
-- 'filters', 'listResolverDnssecConfigs_filters' - An optional specification to return a subset of objects.
--
-- 'maxResults', 'listResolverDnssecConfigs_maxResults' - /Optional/: An integer that specifies the maximum number of DNSSEC
-- configuration results that you want Amazon Route 53 to return. If you
-- don\'t specify a value for @MaxResults@, Route 53 returns up to 100
-- configuration per page.
--
-- 'nextToken', 'listResolverDnssecConfigs_nextToken' - (Optional) If the current Amazon Web Services account has more than
-- @MaxResults@ DNSSEC configurations, use @NextToken@ to get the second
-- and subsequent pages of results.
--
-- For the first @ListResolverDnssecConfigs@ request, omit this value.
--
-- For the second and subsequent requests, get the value of @NextToken@
-- from the previous response and specify that value for @NextToken@ in the
-- request.
newListResolverDnssecConfigs ::
  ListResolverDnssecConfigs
newListResolverDnssecConfigs :: ListResolverDnssecConfigs
newListResolverDnssecConfigs =
  ListResolverDnssecConfigs'
    { $sel:filters:ListResolverDnssecConfigs' :: Maybe [Filter]
filters =
        forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListResolverDnssecConfigs' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListResolverDnssecConfigs' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | An optional specification to return a subset of objects.
listResolverDnssecConfigs_filters :: Lens.Lens' ListResolverDnssecConfigs (Prelude.Maybe [Filter])
listResolverDnssecConfigs_filters :: Lens' ListResolverDnssecConfigs (Maybe [Filter])
listResolverDnssecConfigs_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverDnssecConfigs' {Maybe [Filter]
filters :: Maybe [Filter]
$sel:filters:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe [Filter]
filters} -> Maybe [Filter]
filters) (\s :: ListResolverDnssecConfigs
s@ListResolverDnssecConfigs' {} Maybe [Filter]
a -> ListResolverDnssecConfigs
s {$sel:filters:ListResolverDnssecConfigs' :: Maybe [Filter]
filters = Maybe [Filter]
a} :: ListResolverDnssecConfigs) 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

-- | /Optional/: An integer that specifies the maximum number of DNSSEC
-- configuration results that you want Amazon Route 53 to return. If you
-- don\'t specify a value for @MaxResults@, Route 53 returns up to 100
-- configuration per page.
listResolverDnssecConfigs_maxResults :: Lens.Lens' ListResolverDnssecConfigs (Prelude.Maybe Prelude.Natural)
listResolverDnssecConfigs_maxResults :: Lens' ListResolverDnssecConfigs (Maybe Natural)
listResolverDnssecConfigs_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverDnssecConfigs' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListResolverDnssecConfigs
s@ListResolverDnssecConfigs' {} Maybe Natural
a -> ListResolverDnssecConfigs
s {$sel:maxResults:ListResolverDnssecConfigs' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListResolverDnssecConfigs)

-- | (Optional) If the current Amazon Web Services account has more than
-- @MaxResults@ DNSSEC configurations, use @NextToken@ to get the second
-- and subsequent pages of results.
--
-- For the first @ListResolverDnssecConfigs@ request, omit this value.
--
-- For the second and subsequent requests, get the value of @NextToken@
-- from the previous response and specify that value for @NextToken@ in the
-- request.
listResolverDnssecConfigs_nextToken :: Lens.Lens' ListResolverDnssecConfigs (Prelude.Maybe Prelude.Text)
listResolverDnssecConfigs_nextToken :: Lens' ListResolverDnssecConfigs (Maybe Text)
listResolverDnssecConfigs_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverDnssecConfigs' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListResolverDnssecConfigs
s@ListResolverDnssecConfigs' {} Maybe Text
a -> ListResolverDnssecConfigs
s {$sel:nextToken:ListResolverDnssecConfigs' :: Maybe Text
nextToken = Maybe Text
a} :: ListResolverDnssecConfigs)

instance Core.AWSPager ListResolverDnssecConfigs where
  page :: ListResolverDnssecConfigs
-> AWSResponse ListResolverDnssecConfigs
-> Maybe ListResolverDnssecConfigs
page ListResolverDnssecConfigs
rq AWSResponse ListResolverDnssecConfigs
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListResolverDnssecConfigs
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListResolverDnssecConfigsResponse (Maybe Text)
listResolverDnssecConfigsResponse_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 ListResolverDnssecConfigs
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListResolverDnssecConfigsResponse (Maybe [ResolverDnssecConfig])
listResolverDnssecConfigsResponse_resolverDnssecConfigs
            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.$ ListResolverDnssecConfigs
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListResolverDnssecConfigs (Maybe Text)
listResolverDnssecConfigs_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListResolverDnssecConfigs
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListResolverDnssecConfigsResponse (Maybe Text)
listResolverDnssecConfigsResponse_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 ListResolverDnssecConfigs where
  type
    AWSResponse ListResolverDnssecConfigs =
      ListResolverDnssecConfigsResponse
  request :: (Service -> Service)
-> ListResolverDnssecConfigs -> Request ListResolverDnssecConfigs
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 ListResolverDnssecConfigs
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListResolverDnssecConfigs)))
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 Text
-> Maybe [ResolverDnssecConfig]
-> Int
-> ListResolverDnssecConfigsResponse
ListResolverDnssecConfigsResponse'
            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
"NextToken")
            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
"ResolverDnssecConfigs"
                            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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ListResolverDnssecConfigs where
  hashWithSalt :: Int -> ListResolverDnssecConfigs -> Int
hashWithSalt Int
_salt ListResolverDnssecConfigs' {Maybe Natural
Maybe [Filter]
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [Filter]
$sel:nextToken:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Text
$sel:maxResults:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Natural
$sel:filters:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe [Filter]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Filter]
filters
      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 ListResolverDnssecConfigs where
  rnf :: ListResolverDnssecConfigs -> ()
rnf ListResolverDnssecConfigs' {Maybe Natural
Maybe [Filter]
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [Filter]
$sel:nextToken:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Text
$sel:maxResults:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Natural
$sel:filters:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe [Filter]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Filter]
filters
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 ListResolverDnssecConfigs where
  toHeaders :: ListResolverDnssecConfigs -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"Route53Resolver.ListResolverDnssecConfigs" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON ListResolverDnssecConfigs where
  toJSON :: ListResolverDnssecConfigs -> Value
toJSON ListResolverDnssecConfigs' {Maybe Natural
Maybe [Filter]
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [Filter]
$sel:nextToken:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Text
$sel:maxResults:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe Natural
$sel:filters:ListResolverDnssecConfigs' :: ListResolverDnssecConfigs -> Maybe [Filter]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Filters" 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 [Filter]
filters,
            (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 ListResolverDnssecConfigs where
  toPath :: ListResolverDnssecConfigs -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | /See:/ 'newListResolverDnssecConfigsResponse' smart constructor.
data ListResolverDnssecConfigsResponse = ListResolverDnssecConfigsResponse'
  { -- | If a response includes the last of the DNSSEC configurations that are
    -- associated with the current Amazon Web Services account, @NextToken@
    -- doesn\'t appear in the response.
    --
    -- If a response doesn\'t include the last of the configurations, you can
    -- get more configurations by submitting another
    -- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_ListResolverDnssecConfigs.html ListResolverDnssecConfigs>
    -- request. Get the value of @NextToken@ that Amazon Route 53 returned in
    -- the previous response and include it in @NextToken@ in the next request.
    ListResolverDnssecConfigsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An array that contains one
    -- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_ResolverDnssecConfig.html ResolverDnssecConfig>
    -- element for each configuration for DNSSEC validation that is associated
    -- with the current Amazon Web Services account.
    ListResolverDnssecConfigsResponse -> Maybe [ResolverDnssecConfig]
resolverDnssecConfigs :: Prelude.Maybe [ResolverDnssecConfig],
    -- | The response's http status code.
    ListResolverDnssecConfigsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListResolverDnssecConfigsResponse
-> ListResolverDnssecConfigsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListResolverDnssecConfigsResponse
-> ListResolverDnssecConfigsResponse -> Bool
$c/= :: ListResolverDnssecConfigsResponse
-> ListResolverDnssecConfigsResponse -> Bool
== :: ListResolverDnssecConfigsResponse
-> ListResolverDnssecConfigsResponse -> Bool
$c== :: ListResolverDnssecConfigsResponse
-> ListResolverDnssecConfigsResponse -> Bool
Prelude.Eq, ReadPrec [ListResolverDnssecConfigsResponse]
ReadPrec ListResolverDnssecConfigsResponse
Int -> ReadS ListResolverDnssecConfigsResponse
ReadS [ListResolverDnssecConfigsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListResolverDnssecConfigsResponse]
$creadListPrec :: ReadPrec [ListResolverDnssecConfigsResponse]
readPrec :: ReadPrec ListResolverDnssecConfigsResponse
$creadPrec :: ReadPrec ListResolverDnssecConfigsResponse
readList :: ReadS [ListResolverDnssecConfigsResponse]
$creadList :: ReadS [ListResolverDnssecConfigsResponse]
readsPrec :: Int -> ReadS ListResolverDnssecConfigsResponse
$creadsPrec :: Int -> ReadS ListResolverDnssecConfigsResponse
Prelude.Read, Int -> ListResolverDnssecConfigsResponse -> ShowS
[ListResolverDnssecConfigsResponse] -> ShowS
ListResolverDnssecConfigsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListResolverDnssecConfigsResponse] -> ShowS
$cshowList :: [ListResolverDnssecConfigsResponse] -> ShowS
show :: ListResolverDnssecConfigsResponse -> String
$cshow :: ListResolverDnssecConfigsResponse -> String
showsPrec :: Int -> ListResolverDnssecConfigsResponse -> ShowS
$cshowsPrec :: Int -> ListResolverDnssecConfigsResponse -> ShowS
Prelude.Show, forall x.
Rep ListResolverDnssecConfigsResponse x
-> ListResolverDnssecConfigsResponse
forall x.
ListResolverDnssecConfigsResponse
-> Rep ListResolverDnssecConfigsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListResolverDnssecConfigsResponse x
-> ListResolverDnssecConfigsResponse
$cfrom :: forall x.
ListResolverDnssecConfigsResponse
-> Rep ListResolverDnssecConfigsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListResolverDnssecConfigsResponse' 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', 'listResolverDnssecConfigsResponse_nextToken' - If a response includes the last of the DNSSEC configurations that are
-- associated with the current Amazon Web Services account, @NextToken@
-- doesn\'t appear in the response.
--
-- If a response doesn\'t include the last of the configurations, you can
-- get more configurations by submitting another
-- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_ListResolverDnssecConfigs.html ListResolverDnssecConfigs>
-- request. Get the value of @NextToken@ that Amazon Route 53 returned in
-- the previous response and include it in @NextToken@ in the next request.
--
-- 'resolverDnssecConfigs', 'listResolverDnssecConfigsResponse_resolverDnssecConfigs' - An array that contains one
-- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_ResolverDnssecConfig.html ResolverDnssecConfig>
-- element for each configuration for DNSSEC validation that is associated
-- with the current Amazon Web Services account.
--
-- 'httpStatus', 'listResolverDnssecConfigsResponse_httpStatus' - The response's http status code.
newListResolverDnssecConfigsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListResolverDnssecConfigsResponse
newListResolverDnssecConfigsResponse :: Int -> ListResolverDnssecConfigsResponse
newListResolverDnssecConfigsResponse Int
pHttpStatus_ =
  ListResolverDnssecConfigsResponse'
    { $sel:nextToken:ListResolverDnssecConfigsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:resolverDnssecConfigs:ListResolverDnssecConfigsResponse' :: Maybe [ResolverDnssecConfig]
resolverDnssecConfigs = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListResolverDnssecConfigsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If a response includes the last of the DNSSEC configurations that are
-- associated with the current Amazon Web Services account, @NextToken@
-- doesn\'t appear in the response.
--
-- If a response doesn\'t include the last of the configurations, you can
-- get more configurations by submitting another
-- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_ListResolverDnssecConfigs.html ListResolverDnssecConfigs>
-- request. Get the value of @NextToken@ that Amazon Route 53 returned in
-- the previous response and include it in @NextToken@ in the next request.
listResolverDnssecConfigsResponse_nextToken :: Lens.Lens' ListResolverDnssecConfigsResponse (Prelude.Maybe Prelude.Text)
listResolverDnssecConfigsResponse_nextToken :: Lens' ListResolverDnssecConfigsResponse (Maybe Text)
listResolverDnssecConfigsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverDnssecConfigsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListResolverDnssecConfigsResponse' :: ListResolverDnssecConfigsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListResolverDnssecConfigsResponse
s@ListResolverDnssecConfigsResponse' {} Maybe Text
a -> ListResolverDnssecConfigsResponse
s {$sel:nextToken:ListResolverDnssecConfigsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListResolverDnssecConfigsResponse)

-- | An array that contains one
-- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_ResolverDnssecConfig.html ResolverDnssecConfig>
-- element for each configuration for DNSSEC validation that is associated
-- with the current Amazon Web Services account.
listResolverDnssecConfigsResponse_resolverDnssecConfigs :: Lens.Lens' ListResolverDnssecConfigsResponse (Prelude.Maybe [ResolverDnssecConfig])
listResolverDnssecConfigsResponse_resolverDnssecConfigs :: Lens'
  ListResolverDnssecConfigsResponse (Maybe [ResolverDnssecConfig])
listResolverDnssecConfigsResponse_resolverDnssecConfigs = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverDnssecConfigsResponse' {Maybe [ResolverDnssecConfig]
resolverDnssecConfigs :: Maybe [ResolverDnssecConfig]
$sel:resolverDnssecConfigs:ListResolverDnssecConfigsResponse' :: ListResolverDnssecConfigsResponse -> Maybe [ResolverDnssecConfig]
resolverDnssecConfigs} -> Maybe [ResolverDnssecConfig]
resolverDnssecConfigs) (\s :: ListResolverDnssecConfigsResponse
s@ListResolverDnssecConfigsResponse' {} Maybe [ResolverDnssecConfig]
a -> ListResolverDnssecConfigsResponse
s {$sel:resolverDnssecConfigs:ListResolverDnssecConfigsResponse' :: Maybe [ResolverDnssecConfig]
resolverDnssecConfigs = Maybe [ResolverDnssecConfig]
a} :: ListResolverDnssecConfigsResponse) 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

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

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