{-# 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.ListResolverEndpointIpAddresses
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets the IP addresses for a specified Resolver endpoint.
--
-- This operation returns paginated results.
module Amazonka.Route53Resolver.ListResolverEndpointIpAddresses
  ( -- * Creating a Request
    ListResolverEndpointIpAddresses (..),
    newListResolverEndpointIpAddresses,

    -- * Request Lenses
    listResolverEndpointIpAddresses_maxResults,
    listResolverEndpointIpAddresses_nextToken,
    listResolverEndpointIpAddresses_resolverEndpointId,

    -- * Destructuring the Response
    ListResolverEndpointIpAddressesResponse (..),
    newListResolverEndpointIpAddressesResponse,

    -- * Response Lenses
    listResolverEndpointIpAddressesResponse_ipAddresses,
    listResolverEndpointIpAddressesResponse_maxResults,
    listResolverEndpointIpAddressesResponse_nextToken,
    listResolverEndpointIpAddressesResponse_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:/ 'newListResolverEndpointIpAddresses' smart constructor.
data ListResolverEndpointIpAddresses = ListResolverEndpointIpAddresses'
  { -- | The maximum number of IP addresses that you want to return in the
    -- response to a @ListResolverEndpointIpAddresses@ request. If you don\'t
    -- specify a value for @MaxResults@, Resolver returns up to 100 IP
    -- addresses.
    ListResolverEndpointIpAddresses -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | For the first @ListResolverEndpointIpAddresses@ request, omit this
    -- value.
    --
    -- If the specified Resolver endpoint has more than @MaxResults@ IP
    -- addresses, you can submit another @ListResolverEndpointIpAddresses@
    -- request to get the next group of IP addresses. In the next request,
    -- specify the value of @NextToken@ from the previous response.
    ListResolverEndpointIpAddresses -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The ID of the Resolver endpoint that you want to get IP addresses for.
    ListResolverEndpointIpAddresses -> Text
resolverEndpointId :: Prelude.Text
  }
  deriving (ListResolverEndpointIpAddresses
-> ListResolverEndpointIpAddresses -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListResolverEndpointIpAddresses
-> ListResolverEndpointIpAddresses -> Bool
$c/= :: ListResolverEndpointIpAddresses
-> ListResolverEndpointIpAddresses -> Bool
== :: ListResolverEndpointIpAddresses
-> ListResolverEndpointIpAddresses -> Bool
$c== :: ListResolverEndpointIpAddresses
-> ListResolverEndpointIpAddresses -> Bool
Prelude.Eq, ReadPrec [ListResolverEndpointIpAddresses]
ReadPrec ListResolverEndpointIpAddresses
Int -> ReadS ListResolverEndpointIpAddresses
ReadS [ListResolverEndpointIpAddresses]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListResolverEndpointIpAddresses]
$creadListPrec :: ReadPrec [ListResolverEndpointIpAddresses]
readPrec :: ReadPrec ListResolverEndpointIpAddresses
$creadPrec :: ReadPrec ListResolverEndpointIpAddresses
readList :: ReadS [ListResolverEndpointIpAddresses]
$creadList :: ReadS [ListResolverEndpointIpAddresses]
readsPrec :: Int -> ReadS ListResolverEndpointIpAddresses
$creadsPrec :: Int -> ReadS ListResolverEndpointIpAddresses
Prelude.Read, Int -> ListResolverEndpointIpAddresses -> ShowS
[ListResolverEndpointIpAddresses] -> ShowS
ListResolverEndpointIpAddresses -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListResolverEndpointIpAddresses] -> ShowS
$cshowList :: [ListResolverEndpointIpAddresses] -> ShowS
show :: ListResolverEndpointIpAddresses -> String
$cshow :: ListResolverEndpointIpAddresses -> String
showsPrec :: Int -> ListResolverEndpointIpAddresses -> ShowS
$cshowsPrec :: Int -> ListResolverEndpointIpAddresses -> ShowS
Prelude.Show, forall x.
Rep ListResolverEndpointIpAddresses x
-> ListResolverEndpointIpAddresses
forall x.
ListResolverEndpointIpAddresses
-> Rep ListResolverEndpointIpAddresses x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListResolverEndpointIpAddresses x
-> ListResolverEndpointIpAddresses
$cfrom :: forall x.
ListResolverEndpointIpAddresses
-> Rep ListResolverEndpointIpAddresses x
Prelude.Generic)

-- |
-- Create a value of 'ListResolverEndpointIpAddresses' 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', 'listResolverEndpointIpAddresses_maxResults' - The maximum number of IP addresses that you want to return in the
-- response to a @ListResolverEndpointIpAddresses@ request. If you don\'t
-- specify a value for @MaxResults@, Resolver returns up to 100 IP
-- addresses.
--
-- 'nextToken', 'listResolverEndpointIpAddresses_nextToken' - For the first @ListResolverEndpointIpAddresses@ request, omit this
-- value.
--
-- If the specified Resolver endpoint has more than @MaxResults@ IP
-- addresses, you can submit another @ListResolverEndpointIpAddresses@
-- request to get the next group of IP addresses. In the next request,
-- specify the value of @NextToken@ from the previous response.
--
-- 'resolverEndpointId', 'listResolverEndpointIpAddresses_resolverEndpointId' - The ID of the Resolver endpoint that you want to get IP addresses for.
newListResolverEndpointIpAddresses ::
  -- | 'resolverEndpointId'
  Prelude.Text ->
  ListResolverEndpointIpAddresses
newListResolverEndpointIpAddresses :: Text -> ListResolverEndpointIpAddresses
newListResolverEndpointIpAddresses
  Text
pResolverEndpointId_ =
    ListResolverEndpointIpAddresses'
      { $sel:maxResults:ListResolverEndpointIpAddresses' :: Maybe Natural
maxResults =
          forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListResolverEndpointIpAddresses' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:resolverEndpointId:ListResolverEndpointIpAddresses' :: Text
resolverEndpointId = Text
pResolverEndpointId_
      }

-- | The maximum number of IP addresses that you want to return in the
-- response to a @ListResolverEndpointIpAddresses@ request. If you don\'t
-- specify a value for @MaxResults@, Resolver returns up to 100 IP
-- addresses.
listResolverEndpointIpAddresses_maxResults :: Lens.Lens' ListResolverEndpointIpAddresses (Prelude.Maybe Prelude.Natural)
listResolverEndpointIpAddresses_maxResults :: Lens' ListResolverEndpointIpAddresses (Maybe Natural)
listResolverEndpointIpAddresses_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverEndpointIpAddresses' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListResolverEndpointIpAddresses
s@ListResolverEndpointIpAddresses' {} Maybe Natural
a -> ListResolverEndpointIpAddresses
s {$sel:maxResults:ListResolverEndpointIpAddresses' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListResolverEndpointIpAddresses)

-- | For the first @ListResolverEndpointIpAddresses@ request, omit this
-- value.
--
-- If the specified Resolver endpoint has more than @MaxResults@ IP
-- addresses, you can submit another @ListResolverEndpointIpAddresses@
-- request to get the next group of IP addresses. In the next request,
-- specify the value of @NextToken@ from the previous response.
listResolverEndpointIpAddresses_nextToken :: Lens.Lens' ListResolverEndpointIpAddresses (Prelude.Maybe Prelude.Text)
listResolverEndpointIpAddresses_nextToken :: Lens' ListResolverEndpointIpAddresses (Maybe Text)
listResolverEndpointIpAddresses_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverEndpointIpAddresses' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListResolverEndpointIpAddresses
s@ListResolverEndpointIpAddresses' {} Maybe Text
a -> ListResolverEndpointIpAddresses
s {$sel:nextToken:ListResolverEndpointIpAddresses' :: Maybe Text
nextToken = Maybe Text
a} :: ListResolverEndpointIpAddresses)

-- | The ID of the Resolver endpoint that you want to get IP addresses for.
listResolverEndpointIpAddresses_resolverEndpointId :: Lens.Lens' ListResolverEndpointIpAddresses Prelude.Text
listResolverEndpointIpAddresses_resolverEndpointId :: Lens' ListResolverEndpointIpAddresses Text
listResolverEndpointIpAddresses_resolverEndpointId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverEndpointIpAddresses' {Text
resolverEndpointId :: Text
$sel:resolverEndpointId:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Text
resolverEndpointId} -> Text
resolverEndpointId) (\s :: ListResolverEndpointIpAddresses
s@ListResolverEndpointIpAddresses' {} Text
a -> ListResolverEndpointIpAddresses
s {$sel:resolverEndpointId:ListResolverEndpointIpAddresses' :: Text
resolverEndpointId = Text
a} :: ListResolverEndpointIpAddresses)

instance
  Core.AWSPager
    ListResolverEndpointIpAddresses
  where
  page :: ListResolverEndpointIpAddresses
-> AWSResponse ListResolverEndpointIpAddresses
-> Maybe ListResolverEndpointIpAddresses
page ListResolverEndpointIpAddresses
rq AWSResponse ListResolverEndpointIpAddresses
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListResolverEndpointIpAddresses
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListResolverEndpointIpAddressesResponse (Maybe Text)
listResolverEndpointIpAddressesResponse_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 ListResolverEndpointIpAddresses
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListResolverEndpointIpAddressesResponse (Maybe [IpAddressResponse])
listResolverEndpointIpAddressesResponse_ipAddresses
            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.$ ListResolverEndpointIpAddresses
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListResolverEndpointIpAddresses (Maybe Text)
listResolverEndpointIpAddresses_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListResolverEndpointIpAddresses
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListResolverEndpointIpAddressesResponse (Maybe Text)
listResolverEndpointIpAddressesResponse_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
    ListResolverEndpointIpAddresses
  where
  type
    AWSResponse ListResolverEndpointIpAddresses =
      ListResolverEndpointIpAddressesResponse
  request :: (Service -> Service)
-> ListResolverEndpointIpAddresses
-> Request ListResolverEndpointIpAddresses
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 ListResolverEndpointIpAddresses
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse ListResolverEndpointIpAddresses)))
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 [IpAddressResponse]
-> Maybe Natural
-> Maybe Text
-> Int
-> ListResolverEndpointIpAddressesResponse
ListResolverEndpointIpAddressesResponse'
            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
"IpAddresses" 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
"MaxResults")
            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
    ListResolverEndpointIpAddresses
  where
  hashWithSalt :: Int -> ListResolverEndpointIpAddresses -> Int
hashWithSalt
    Int
_salt
    ListResolverEndpointIpAddresses' {Maybe Natural
Maybe Text
Text
resolverEndpointId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:resolverEndpointId:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Text
$sel:nextToken:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Maybe Text
$sel:maxResults:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> 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
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
resolverEndpointId

instance
  Prelude.NFData
    ListResolverEndpointIpAddresses
  where
  rnf :: ListResolverEndpointIpAddresses -> ()
rnf ListResolverEndpointIpAddresses' {Maybe Natural
Maybe Text
Text
resolverEndpointId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:resolverEndpointId:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Text
$sel:nextToken:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Maybe Text
$sel:maxResults:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> 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
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
resolverEndpointId

instance
  Data.ToHeaders
    ListResolverEndpointIpAddresses
  where
  toHeaders :: ListResolverEndpointIpAddresses -> 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.ListResolverEndpointIpAddresses" ::
                          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 ListResolverEndpointIpAddresses where
  toJSON :: ListResolverEndpointIpAddresses -> Value
toJSON ListResolverEndpointIpAddresses' {Maybe Natural
Maybe Text
Text
resolverEndpointId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:resolverEndpointId:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Text
$sel:nextToken:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> Maybe Text
$sel:maxResults:ListResolverEndpointIpAddresses' :: ListResolverEndpointIpAddresses -> 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,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ResolverEndpointId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
resolverEndpointId)
          ]
      )

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

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

-- | /See:/ 'newListResolverEndpointIpAddressesResponse' smart constructor.
data ListResolverEndpointIpAddressesResponse = ListResolverEndpointIpAddressesResponse'
  { -- | Information about the IP addresses in your VPC that DNS queries
    -- originate from (for outbound endpoints) or that you forward DNS queries
    -- to (for inbound endpoints).
    ListResolverEndpointIpAddressesResponse
-> Maybe [IpAddressResponse]
ipAddresses :: Prelude.Maybe [IpAddressResponse],
    -- | The value that you specified for @MaxResults@ in the request.
    ListResolverEndpointIpAddressesResponse -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | If the specified endpoint has more than @MaxResults@ IP addresses, you
    -- can submit another @ListResolverEndpointIpAddresses@ request to get the
    -- next group of IP addresses. In the next request, specify the value of
    -- @NextToken@ from the previous response.
    ListResolverEndpointIpAddressesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListResolverEndpointIpAddressesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListResolverEndpointIpAddressesResponse
-> ListResolverEndpointIpAddressesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListResolverEndpointIpAddressesResponse
-> ListResolverEndpointIpAddressesResponse -> Bool
$c/= :: ListResolverEndpointIpAddressesResponse
-> ListResolverEndpointIpAddressesResponse -> Bool
== :: ListResolverEndpointIpAddressesResponse
-> ListResolverEndpointIpAddressesResponse -> Bool
$c== :: ListResolverEndpointIpAddressesResponse
-> ListResolverEndpointIpAddressesResponse -> Bool
Prelude.Eq, ReadPrec [ListResolverEndpointIpAddressesResponse]
ReadPrec ListResolverEndpointIpAddressesResponse
Int -> ReadS ListResolverEndpointIpAddressesResponse
ReadS [ListResolverEndpointIpAddressesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListResolverEndpointIpAddressesResponse]
$creadListPrec :: ReadPrec [ListResolverEndpointIpAddressesResponse]
readPrec :: ReadPrec ListResolverEndpointIpAddressesResponse
$creadPrec :: ReadPrec ListResolverEndpointIpAddressesResponse
readList :: ReadS [ListResolverEndpointIpAddressesResponse]
$creadList :: ReadS [ListResolverEndpointIpAddressesResponse]
readsPrec :: Int -> ReadS ListResolverEndpointIpAddressesResponse
$creadsPrec :: Int -> ReadS ListResolverEndpointIpAddressesResponse
Prelude.Read, Int -> ListResolverEndpointIpAddressesResponse -> ShowS
[ListResolverEndpointIpAddressesResponse] -> ShowS
ListResolverEndpointIpAddressesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListResolverEndpointIpAddressesResponse] -> ShowS
$cshowList :: [ListResolverEndpointIpAddressesResponse] -> ShowS
show :: ListResolverEndpointIpAddressesResponse -> String
$cshow :: ListResolverEndpointIpAddressesResponse -> String
showsPrec :: Int -> ListResolverEndpointIpAddressesResponse -> ShowS
$cshowsPrec :: Int -> ListResolverEndpointIpAddressesResponse -> ShowS
Prelude.Show, forall x.
Rep ListResolverEndpointIpAddressesResponse x
-> ListResolverEndpointIpAddressesResponse
forall x.
ListResolverEndpointIpAddressesResponse
-> Rep ListResolverEndpointIpAddressesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListResolverEndpointIpAddressesResponse x
-> ListResolverEndpointIpAddressesResponse
$cfrom :: forall x.
ListResolverEndpointIpAddressesResponse
-> Rep ListResolverEndpointIpAddressesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListResolverEndpointIpAddressesResponse' 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:
--
-- 'ipAddresses', 'listResolverEndpointIpAddressesResponse_ipAddresses' - Information about the IP addresses in your VPC that DNS queries
-- originate from (for outbound endpoints) or that you forward DNS queries
-- to (for inbound endpoints).
--
-- 'maxResults', 'listResolverEndpointIpAddressesResponse_maxResults' - The value that you specified for @MaxResults@ in the request.
--
-- 'nextToken', 'listResolverEndpointIpAddressesResponse_nextToken' - If the specified endpoint has more than @MaxResults@ IP addresses, you
-- can submit another @ListResolverEndpointIpAddresses@ request to get the
-- next group of IP addresses. In the next request, specify the value of
-- @NextToken@ from the previous response.
--
-- 'httpStatus', 'listResolverEndpointIpAddressesResponse_httpStatus' - The response's http status code.
newListResolverEndpointIpAddressesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListResolverEndpointIpAddressesResponse
newListResolverEndpointIpAddressesResponse :: Int -> ListResolverEndpointIpAddressesResponse
newListResolverEndpointIpAddressesResponse
  Int
pHttpStatus_ =
    ListResolverEndpointIpAddressesResponse'
      { $sel:ipAddresses:ListResolverEndpointIpAddressesResponse' :: Maybe [IpAddressResponse]
ipAddresses =
          forall a. Maybe a
Prelude.Nothing,
        $sel:maxResults:ListResolverEndpointIpAddressesResponse' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListResolverEndpointIpAddressesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:ListResolverEndpointIpAddressesResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Information about the IP addresses in your VPC that DNS queries
-- originate from (for outbound endpoints) or that you forward DNS queries
-- to (for inbound endpoints).
listResolverEndpointIpAddressesResponse_ipAddresses :: Lens.Lens' ListResolverEndpointIpAddressesResponse (Prelude.Maybe [IpAddressResponse])
listResolverEndpointIpAddressesResponse_ipAddresses :: Lens'
  ListResolverEndpointIpAddressesResponse (Maybe [IpAddressResponse])
listResolverEndpointIpAddressesResponse_ipAddresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverEndpointIpAddressesResponse' {Maybe [IpAddressResponse]
ipAddresses :: Maybe [IpAddressResponse]
$sel:ipAddresses:ListResolverEndpointIpAddressesResponse' :: ListResolverEndpointIpAddressesResponse
-> Maybe [IpAddressResponse]
ipAddresses} -> Maybe [IpAddressResponse]
ipAddresses) (\s :: ListResolverEndpointIpAddressesResponse
s@ListResolverEndpointIpAddressesResponse' {} Maybe [IpAddressResponse]
a -> ListResolverEndpointIpAddressesResponse
s {$sel:ipAddresses:ListResolverEndpointIpAddressesResponse' :: Maybe [IpAddressResponse]
ipAddresses = Maybe [IpAddressResponse]
a} :: ListResolverEndpointIpAddressesResponse) 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 value that you specified for @MaxResults@ in the request.
listResolverEndpointIpAddressesResponse_maxResults :: Lens.Lens' ListResolverEndpointIpAddressesResponse (Prelude.Maybe Prelude.Natural)
listResolverEndpointIpAddressesResponse_maxResults :: Lens' ListResolverEndpointIpAddressesResponse (Maybe Natural)
listResolverEndpointIpAddressesResponse_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverEndpointIpAddressesResponse' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListResolverEndpointIpAddressesResponse' :: ListResolverEndpointIpAddressesResponse -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListResolverEndpointIpAddressesResponse
s@ListResolverEndpointIpAddressesResponse' {} Maybe Natural
a -> ListResolverEndpointIpAddressesResponse
s {$sel:maxResults:ListResolverEndpointIpAddressesResponse' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListResolverEndpointIpAddressesResponse)

-- | If the specified endpoint has more than @MaxResults@ IP addresses, you
-- can submit another @ListResolverEndpointIpAddresses@ request to get the
-- next group of IP addresses. In the next request, specify the value of
-- @NextToken@ from the previous response.
listResolverEndpointIpAddressesResponse_nextToken :: Lens.Lens' ListResolverEndpointIpAddressesResponse (Prelude.Maybe Prelude.Text)
listResolverEndpointIpAddressesResponse_nextToken :: Lens' ListResolverEndpointIpAddressesResponse (Maybe Text)
listResolverEndpointIpAddressesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListResolverEndpointIpAddressesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListResolverEndpointIpAddressesResponse' :: ListResolverEndpointIpAddressesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListResolverEndpointIpAddressesResponse
s@ListResolverEndpointIpAddressesResponse' {} Maybe Text
a -> ListResolverEndpointIpAddressesResponse
s {$sel:nextToken:ListResolverEndpointIpAddressesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListResolverEndpointIpAddressesResponse)

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

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