{-# 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.NetworkManager.ListPeerings
-- 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 peerings for a core network.
--
-- This operation returns paginated results.
module Amazonka.NetworkManager.ListPeerings
  ( -- * Creating a Request
    ListPeerings (..),
    newListPeerings,

    -- * Request Lenses
    listPeerings_coreNetworkId,
    listPeerings_edgeLocation,
    listPeerings_maxResults,
    listPeerings_nextToken,
    listPeerings_peeringType,
    listPeerings_state,

    -- * Destructuring the Response
    ListPeeringsResponse (..),
    newListPeeringsResponse,

    -- * Response Lenses
    listPeeringsResponse_nextToken,
    listPeeringsResponse_peerings,
    listPeeringsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListPeerings' smart constructor.
data ListPeerings = ListPeerings'
  { -- | The ID of a core network.
    ListPeerings -> Maybe Text
coreNetworkId :: Prelude.Maybe Prelude.Text,
    -- | Returns a list edge locations for the
    ListPeerings -> Maybe Text
edgeLocation :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of results to return.
    ListPeerings -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token for the next page of results.
    ListPeerings -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Returns a list of a peering requests.
    ListPeerings -> Maybe PeeringType
peeringType :: Prelude.Maybe PeeringType,
    -- | Returns a list of the peering request states.
    ListPeerings -> Maybe PeeringState
state :: Prelude.Maybe PeeringState
  }
  deriving (ListPeerings -> ListPeerings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListPeerings -> ListPeerings -> Bool
$c/= :: ListPeerings -> ListPeerings -> Bool
== :: ListPeerings -> ListPeerings -> Bool
$c== :: ListPeerings -> ListPeerings -> Bool
Prelude.Eq, ReadPrec [ListPeerings]
ReadPrec ListPeerings
Int -> ReadS ListPeerings
ReadS [ListPeerings]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListPeerings]
$creadListPrec :: ReadPrec [ListPeerings]
readPrec :: ReadPrec ListPeerings
$creadPrec :: ReadPrec ListPeerings
readList :: ReadS [ListPeerings]
$creadList :: ReadS [ListPeerings]
readsPrec :: Int -> ReadS ListPeerings
$creadsPrec :: Int -> ReadS ListPeerings
Prelude.Read, Int -> ListPeerings -> ShowS
[ListPeerings] -> ShowS
ListPeerings -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListPeerings] -> ShowS
$cshowList :: [ListPeerings] -> ShowS
show :: ListPeerings -> String
$cshow :: ListPeerings -> String
showsPrec :: Int -> ListPeerings -> ShowS
$cshowsPrec :: Int -> ListPeerings -> ShowS
Prelude.Show, forall x. Rep ListPeerings x -> ListPeerings
forall x. ListPeerings -> Rep ListPeerings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListPeerings x -> ListPeerings
$cfrom :: forall x. ListPeerings -> Rep ListPeerings x
Prelude.Generic)

-- |
-- Create a value of 'ListPeerings' 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:
--
-- 'coreNetworkId', 'listPeerings_coreNetworkId' - The ID of a core network.
--
-- 'edgeLocation', 'listPeerings_edgeLocation' - Returns a list edge locations for the
--
-- 'maxResults', 'listPeerings_maxResults' - The maximum number of results to return.
--
-- 'nextToken', 'listPeerings_nextToken' - The token for the next page of results.
--
-- 'peeringType', 'listPeerings_peeringType' - Returns a list of a peering requests.
--
-- 'state', 'listPeerings_state' - Returns a list of the peering request states.
newListPeerings ::
  ListPeerings
newListPeerings :: ListPeerings
newListPeerings =
  ListPeerings'
    { $sel:coreNetworkId:ListPeerings' :: Maybe Text
coreNetworkId = forall a. Maybe a
Prelude.Nothing,
      $sel:edgeLocation:ListPeerings' :: Maybe Text
edgeLocation = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListPeerings' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListPeerings' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:peeringType:ListPeerings' :: Maybe PeeringType
peeringType = forall a. Maybe a
Prelude.Nothing,
      $sel:state:ListPeerings' :: Maybe PeeringState
state = forall a. Maybe a
Prelude.Nothing
    }

-- | The ID of a core network.
listPeerings_coreNetworkId :: Lens.Lens' ListPeerings (Prelude.Maybe Prelude.Text)
listPeerings_coreNetworkId :: Lens' ListPeerings (Maybe Text)
listPeerings_coreNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeerings' {Maybe Text
coreNetworkId :: Maybe Text
$sel:coreNetworkId:ListPeerings' :: ListPeerings -> Maybe Text
coreNetworkId} -> Maybe Text
coreNetworkId) (\s :: ListPeerings
s@ListPeerings' {} Maybe Text
a -> ListPeerings
s {$sel:coreNetworkId:ListPeerings' :: Maybe Text
coreNetworkId = Maybe Text
a} :: ListPeerings)

-- | Returns a list edge locations for the
listPeerings_edgeLocation :: Lens.Lens' ListPeerings (Prelude.Maybe Prelude.Text)
listPeerings_edgeLocation :: Lens' ListPeerings (Maybe Text)
listPeerings_edgeLocation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeerings' {Maybe Text
edgeLocation :: Maybe Text
$sel:edgeLocation:ListPeerings' :: ListPeerings -> Maybe Text
edgeLocation} -> Maybe Text
edgeLocation) (\s :: ListPeerings
s@ListPeerings' {} Maybe Text
a -> ListPeerings
s {$sel:edgeLocation:ListPeerings' :: Maybe Text
edgeLocation = Maybe Text
a} :: ListPeerings)

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

-- | The token for the next page of results.
listPeerings_nextToken :: Lens.Lens' ListPeerings (Prelude.Maybe Prelude.Text)
listPeerings_nextToken :: Lens' ListPeerings (Maybe Text)
listPeerings_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeerings' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListPeerings' :: ListPeerings -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListPeerings
s@ListPeerings' {} Maybe Text
a -> ListPeerings
s {$sel:nextToken:ListPeerings' :: Maybe Text
nextToken = Maybe Text
a} :: ListPeerings)

-- | Returns a list of a peering requests.
listPeerings_peeringType :: Lens.Lens' ListPeerings (Prelude.Maybe PeeringType)
listPeerings_peeringType :: Lens' ListPeerings (Maybe PeeringType)
listPeerings_peeringType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeerings' {Maybe PeeringType
peeringType :: Maybe PeeringType
$sel:peeringType:ListPeerings' :: ListPeerings -> Maybe PeeringType
peeringType} -> Maybe PeeringType
peeringType) (\s :: ListPeerings
s@ListPeerings' {} Maybe PeeringType
a -> ListPeerings
s {$sel:peeringType:ListPeerings' :: Maybe PeeringType
peeringType = Maybe PeeringType
a} :: ListPeerings)

-- | Returns a list of the peering request states.
listPeerings_state :: Lens.Lens' ListPeerings (Prelude.Maybe PeeringState)
listPeerings_state :: Lens' ListPeerings (Maybe PeeringState)
listPeerings_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeerings' {Maybe PeeringState
state :: Maybe PeeringState
$sel:state:ListPeerings' :: ListPeerings -> Maybe PeeringState
state} -> Maybe PeeringState
state) (\s :: ListPeerings
s@ListPeerings' {} Maybe PeeringState
a -> ListPeerings
s {$sel:state:ListPeerings' :: Maybe PeeringState
state = Maybe PeeringState
a} :: ListPeerings)

instance Core.AWSPager ListPeerings where
  page :: ListPeerings -> AWSResponse ListPeerings -> Maybe ListPeerings
page ListPeerings
rq AWSResponse ListPeerings
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListPeerings
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListPeeringsResponse (Maybe Text)
listPeeringsResponse_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 ListPeerings
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListPeeringsResponse (Maybe [Peering])
listPeeringsResponse_peerings
            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.$ ListPeerings
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListPeerings (Maybe Text)
listPeerings_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListPeerings
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListPeeringsResponse (Maybe Text)
listPeeringsResponse_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 ListPeerings where
  type AWSResponse ListPeerings = ListPeeringsResponse
  request :: (Service -> Service) -> ListPeerings -> Request ListPeerings
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListPeerings
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListPeerings)))
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 [Peering] -> Int -> ListPeeringsResponse
ListPeeringsResponse'
            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
"Peerings" 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 ListPeerings where
  hashWithSalt :: Int -> ListPeerings -> Int
hashWithSalt Int
_salt ListPeerings' {Maybe Natural
Maybe Text
Maybe PeeringState
Maybe PeeringType
state :: Maybe PeeringState
peeringType :: Maybe PeeringType
nextToken :: Maybe Text
maxResults :: Maybe Natural
edgeLocation :: Maybe Text
coreNetworkId :: Maybe Text
$sel:state:ListPeerings' :: ListPeerings -> Maybe PeeringState
$sel:peeringType:ListPeerings' :: ListPeerings -> Maybe PeeringType
$sel:nextToken:ListPeerings' :: ListPeerings -> Maybe Text
$sel:maxResults:ListPeerings' :: ListPeerings -> Maybe Natural
$sel:edgeLocation:ListPeerings' :: ListPeerings -> Maybe Text
$sel:coreNetworkId:ListPeerings' :: ListPeerings -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
coreNetworkId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
edgeLocation
      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` Maybe PeeringType
peeringType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PeeringState
state

instance Prelude.NFData ListPeerings where
  rnf :: ListPeerings -> ()
rnf ListPeerings' {Maybe Natural
Maybe Text
Maybe PeeringState
Maybe PeeringType
state :: Maybe PeeringState
peeringType :: Maybe PeeringType
nextToken :: Maybe Text
maxResults :: Maybe Natural
edgeLocation :: Maybe Text
coreNetworkId :: Maybe Text
$sel:state:ListPeerings' :: ListPeerings -> Maybe PeeringState
$sel:peeringType:ListPeerings' :: ListPeerings -> Maybe PeeringType
$sel:nextToken:ListPeerings' :: ListPeerings -> Maybe Text
$sel:maxResults:ListPeerings' :: ListPeerings -> Maybe Natural
$sel:edgeLocation:ListPeerings' :: ListPeerings -> Maybe Text
$sel:coreNetworkId:ListPeerings' :: ListPeerings -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
coreNetworkId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
edgeLocation
      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 Maybe PeeringType
peeringType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PeeringState
state

instance Data.ToHeaders ListPeerings where
  toHeaders :: ListPeerings -> 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.ToPath ListPeerings where
  toPath :: ListPeerings -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/peerings"

instance Data.ToQuery ListPeerings where
  toQuery :: ListPeerings -> QueryString
toQuery ListPeerings' {Maybe Natural
Maybe Text
Maybe PeeringState
Maybe PeeringType
state :: Maybe PeeringState
peeringType :: Maybe PeeringType
nextToken :: Maybe Text
maxResults :: Maybe Natural
edgeLocation :: Maybe Text
coreNetworkId :: Maybe Text
$sel:state:ListPeerings' :: ListPeerings -> Maybe PeeringState
$sel:peeringType:ListPeerings' :: ListPeerings -> Maybe PeeringType
$sel:nextToken:ListPeerings' :: ListPeerings -> Maybe Text
$sel:maxResults:ListPeerings' :: ListPeerings -> Maybe Natural
$sel:edgeLocation:ListPeerings' :: ListPeerings -> Maybe Text
$sel:coreNetworkId:ListPeerings' :: ListPeerings -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"coreNetworkId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
coreNetworkId,
        ByteString
"edgeLocation" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
edgeLocation,
        ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"peeringType" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe PeeringType
peeringType,
        ByteString
"state" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe PeeringState
state
      ]

-- | /See:/ 'newListPeeringsResponse' smart constructor.
data ListPeeringsResponse = ListPeeringsResponse'
  { -- | The token for the next page of results.
    ListPeeringsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Lists the transit gateway peerings for the @ListPeerings@ request.
    ListPeeringsResponse -> Maybe [Peering]
peerings :: Prelude.Maybe [Peering],
    -- | The response's http status code.
    ListPeeringsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListPeeringsResponse -> ListPeeringsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListPeeringsResponse -> ListPeeringsResponse -> Bool
$c/= :: ListPeeringsResponse -> ListPeeringsResponse -> Bool
== :: ListPeeringsResponse -> ListPeeringsResponse -> Bool
$c== :: ListPeeringsResponse -> ListPeeringsResponse -> Bool
Prelude.Eq, ReadPrec [ListPeeringsResponse]
ReadPrec ListPeeringsResponse
Int -> ReadS ListPeeringsResponse
ReadS [ListPeeringsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListPeeringsResponse]
$creadListPrec :: ReadPrec [ListPeeringsResponse]
readPrec :: ReadPrec ListPeeringsResponse
$creadPrec :: ReadPrec ListPeeringsResponse
readList :: ReadS [ListPeeringsResponse]
$creadList :: ReadS [ListPeeringsResponse]
readsPrec :: Int -> ReadS ListPeeringsResponse
$creadsPrec :: Int -> ReadS ListPeeringsResponse
Prelude.Read, Int -> ListPeeringsResponse -> ShowS
[ListPeeringsResponse] -> ShowS
ListPeeringsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListPeeringsResponse] -> ShowS
$cshowList :: [ListPeeringsResponse] -> ShowS
show :: ListPeeringsResponse -> String
$cshow :: ListPeeringsResponse -> String
showsPrec :: Int -> ListPeeringsResponse -> ShowS
$cshowsPrec :: Int -> ListPeeringsResponse -> ShowS
Prelude.Show, forall x. Rep ListPeeringsResponse x -> ListPeeringsResponse
forall x. ListPeeringsResponse -> Rep ListPeeringsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListPeeringsResponse x -> ListPeeringsResponse
$cfrom :: forall x. ListPeeringsResponse -> Rep ListPeeringsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListPeeringsResponse' 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', 'listPeeringsResponse_nextToken' - The token for the next page of results.
--
-- 'peerings', 'listPeeringsResponse_peerings' - Lists the transit gateway peerings for the @ListPeerings@ request.
--
-- 'httpStatus', 'listPeeringsResponse_httpStatus' - The response's http status code.
newListPeeringsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListPeeringsResponse
newListPeeringsResponse :: Int -> ListPeeringsResponse
newListPeeringsResponse Int
pHttpStatus_ =
  ListPeeringsResponse'
    { $sel:nextToken:ListPeeringsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:peerings:ListPeeringsResponse' :: Maybe [Peering]
peerings = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListPeeringsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The token for the next page of results.
listPeeringsResponse_nextToken :: Lens.Lens' ListPeeringsResponse (Prelude.Maybe Prelude.Text)
listPeeringsResponse_nextToken :: Lens' ListPeeringsResponse (Maybe Text)
listPeeringsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeeringsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListPeeringsResponse' :: ListPeeringsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListPeeringsResponse
s@ListPeeringsResponse' {} Maybe Text
a -> ListPeeringsResponse
s {$sel:nextToken:ListPeeringsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListPeeringsResponse)

-- | Lists the transit gateway peerings for the @ListPeerings@ request.
listPeeringsResponse_peerings :: Lens.Lens' ListPeeringsResponse (Prelude.Maybe [Peering])
listPeeringsResponse_peerings :: Lens' ListPeeringsResponse (Maybe [Peering])
listPeeringsResponse_peerings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeeringsResponse' {Maybe [Peering]
peerings :: Maybe [Peering]
$sel:peerings:ListPeeringsResponse' :: ListPeeringsResponse -> Maybe [Peering]
peerings} -> Maybe [Peering]
peerings) (\s :: ListPeeringsResponse
s@ListPeeringsResponse' {} Maybe [Peering]
a -> ListPeeringsResponse
s {$sel:peerings:ListPeeringsResponse' :: Maybe [Peering]
peerings = Maybe [Peering]
a} :: ListPeeringsResponse) 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.
listPeeringsResponse_httpStatus :: Lens.Lens' ListPeeringsResponse Prelude.Int
listPeeringsResponse_httpStatus :: Lens' ListPeeringsResponse Int
listPeeringsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPeeringsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListPeeringsResponse' :: ListPeeringsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListPeeringsResponse
s@ListPeeringsResponse' {} Int
a -> ListPeeringsResponse
s {$sel:httpStatus:ListPeeringsResponse' :: Int
httpStatus = Int
a} :: ListPeeringsResponse)

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