{-# 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.CreateTransitGatewayPeering
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a transit gateway peering connection.
module Amazonka.NetworkManager.CreateTransitGatewayPeering
  ( -- * Creating a Request
    CreateTransitGatewayPeering (..),
    newCreateTransitGatewayPeering,

    -- * Request Lenses
    createTransitGatewayPeering_clientToken,
    createTransitGatewayPeering_tags,
    createTransitGatewayPeering_coreNetworkId,
    createTransitGatewayPeering_transitGatewayArn,

    -- * Destructuring the Response
    CreateTransitGatewayPeeringResponse (..),
    newCreateTransitGatewayPeeringResponse,

    -- * Response Lenses
    createTransitGatewayPeeringResponse_transitGatewayPeering,
    createTransitGatewayPeeringResponse_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:/ 'newCreateTransitGatewayPeering' smart constructor.
data CreateTransitGatewayPeering = CreateTransitGatewayPeering'
  { -- | The client token associated with the request.
    CreateTransitGatewayPeering -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The list of key-value tags associated with the request.
    CreateTransitGatewayPeering -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The ID of a core network.
    CreateTransitGatewayPeering -> Text
coreNetworkId :: Prelude.Text,
    -- | The ARN of the transit gateway for the peering request.
    CreateTransitGatewayPeering -> Text
transitGatewayArn :: Prelude.Text
  }
  deriving (CreateTransitGatewayPeering -> CreateTransitGatewayPeering -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransitGatewayPeering -> CreateTransitGatewayPeering -> Bool
$c/= :: CreateTransitGatewayPeering -> CreateTransitGatewayPeering -> Bool
== :: CreateTransitGatewayPeering -> CreateTransitGatewayPeering -> Bool
$c== :: CreateTransitGatewayPeering -> CreateTransitGatewayPeering -> Bool
Prelude.Eq, ReadPrec [CreateTransitGatewayPeering]
ReadPrec CreateTransitGatewayPeering
Int -> ReadS CreateTransitGatewayPeering
ReadS [CreateTransitGatewayPeering]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransitGatewayPeering]
$creadListPrec :: ReadPrec [CreateTransitGatewayPeering]
readPrec :: ReadPrec CreateTransitGatewayPeering
$creadPrec :: ReadPrec CreateTransitGatewayPeering
readList :: ReadS [CreateTransitGatewayPeering]
$creadList :: ReadS [CreateTransitGatewayPeering]
readsPrec :: Int -> ReadS CreateTransitGatewayPeering
$creadsPrec :: Int -> ReadS CreateTransitGatewayPeering
Prelude.Read, Int -> CreateTransitGatewayPeering -> ShowS
[CreateTransitGatewayPeering] -> ShowS
CreateTransitGatewayPeering -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransitGatewayPeering] -> ShowS
$cshowList :: [CreateTransitGatewayPeering] -> ShowS
show :: CreateTransitGatewayPeering -> String
$cshow :: CreateTransitGatewayPeering -> String
showsPrec :: Int -> CreateTransitGatewayPeering -> ShowS
$cshowsPrec :: Int -> CreateTransitGatewayPeering -> ShowS
Prelude.Show, forall x.
Rep CreateTransitGatewayPeering x -> CreateTransitGatewayPeering
forall x.
CreateTransitGatewayPeering -> Rep CreateTransitGatewayPeering x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateTransitGatewayPeering x -> CreateTransitGatewayPeering
$cfrom :: forall x.
CreateTransitGatewayPeering -> Rep CreateTransitGatewayPeering x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransitGatewayPeering' 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:
--
-- 'clientToken', 'createTransitGatewayPeering_clientToken' - The client token associated with the request.
--
-- 'tags', 'createTransitGatewayPeering_tags' - The list of key-value tags associated with the request.
--
-- 'coreNetworkId', 'createTransitGatewayPeering_coreNetworkId' - The ID of a core network.
--
-- 'transitGatewayArn', 'createTransitGatewayPeering_transitGatewayArn' - The ARN of the transit gateway for the peering request.
newCreateTransitGatewayPeering ::
  -- | 'coreNetworkId'
  Prelude.Text ->
  -- | 'transitGatewayArn'
  Prelude.Text ->
  CreateTransitGatewayPeering
newCreateTransitGatewayPeering :: Text -> Text -> CreateTransitGatewayPeering
newCreateTransitGatewayPeering
  Text
pCoreNetworkId_
  Text
pTransitGatewayArn_ =
    CreateTransitGatewayPeering'
      { $sel:clientToken:CreateTransitGatewayPeering' :: Maybe Text
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateTransitGatewayPeering' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:coreNetworkId:CreateTransitGatewayPeering' :: Text
coreNetworkId = Text
pCoreNetworkId_,
        $sel:transitGatewayArn:CreateTransitGatewayPeering' :: Text
transitGatewayArn = Text
pTransitGatewayArn_
      }

-- | The client token associated with the request.
createTransitGatewayPeering_clientToken :: Lens.Lens' CreateTransitGatewayPeering (Prelude.Maybe Prelude.Text)
createTransitGatewayPeering_clientToken :: Lens' CreateTransitGatewayPeering (Maybe Text)
createTransitGatewayPeering_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPeering' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateTransitGatewayPeering
s@CreateTransitGatewayPeering' {} Maybe Text
a -> CreateTransitGatewayPeering
s {$sel:clientToken:CreateTransitGatewayPeering' :: Maybe Text
clientToken = Maybe Text
a} :: CreateTransitGatewayPeering)

-- | The list of key-value tags associated with the request.
createTransitGatewayPeering_tags :: Lens.Lens' CreateTransitGatewayPeering (Prelude.Maybe [Tag])
createTransitGatewayPeering_tags :: Lens' CreateTransitGatewayPeering (Maybe [Tag])
createTransitGatewayPeering_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPeering' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateTransitGatewayPeering
s@CreateTransitGatewayPeering' {} Maybe [Tag]
a -> CreateTransitGatewayPeering
s {$sel:tags:CreateTransitGatewayPeering' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateTransitGatewayPeering) 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 ID of a core network.
createTransitGatewayPeering_coreNetworkId :: Lens.Lens' CreateTransitGatewayPeering Prelude.Text
createTransitGatewayPeering_coreNetworkId :: Lens' CreateTransitGatewayPeering Text
createTransitGatewayPeering_coreNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPeering' {Text
coreNetworkId :: Text
$sel:coreNetworkId:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
coreNetworkId} -> Text
coreNetworkId) (\s :: CreateTransitGatewayPeering
s@CreateTransitGatewayPeering' {} Text
a -> CreateTransitGatewayPeering
s {$sel:coreNetworkId:CreateTransitGatewayPeering' :: Text
coreNetworkId = Text
a} :: CreateTransitGatewayPeering)

-- | The ARN of the transit gateway for the peering request.
createTransitGatewayPeering_transitGatewayArn :: Lens.Lens' CreateTransitGatewayPeering Prelude.Text
createTransitGatewayPeering_transitGatewayArn :: Lens' CreateTransitGatewayPeering Text
createTransitGatewayPeering_transitGatewayArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPeering' {Text
transitGatewayArn :: Text
$sel:transitGatewayArn:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
transitGatewayArn} -> Text
transitGatewayArn) (\s :: CreateTransitGatewayPeering
s@CreateTransitGatewayPeering' {} Text
a -> CreateTransitGatewayPeering
s {$sel:transitGatewayArn:CreateTransitGatewayPeering' :: Text
transitGatewayArn = Text
a} :: CreateTransitGatewayPeering)

instance Core.AWSRequest CreateTransitGatewayPeering where
  type
    AWSResponse CreateTransitGatewayPeering =
      CreateTransitGatewayPeeringResponse
  request :: (Service -> Service)
-> CreateTransitGatewayPeering
-> Request CreateTransitGatewayPeering
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 CreateTransitGatewayPeering
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateTransitGatewayPeering)))
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 TransitGatewayPeering
-> Int -> CreateTransitGatewayPeeringResponse
CreateTransitGatewayPeeringResponse'
            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
"TransitGatewayPeering")
            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 CreateTransitGatewayPeering where
  hashWithSalt :: Int -> CreateTransitGatewayPeering -> Int
hashWithSalt Int
_salt CreateTransitGatewayPeering' {Maybe [Tag]
Maybe Text
Text
transitGatewayArn :: Text
coreNetworkId :: Text
tags :: Maybe [Tag]
clientToken :: Maybe Text
$sel:transitGatewayArn:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
$sel:coreNetworkId:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
$sel:tags:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe [Tag]
$sel:clientToken:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
coreNetworkId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
transitGatewayArn

instance Prelude.NFData CreateTransitGatewayPeering where
  rnf :: CreateTransitGatewayPeering -> ()
rnf CreateTransitGatewayPeering' {Maybe [Tag]
Maybe Text
Text
transitGatewayArn :: Text
coreNetworkId :: Text
tags :: Maybe [Tag]
clientToken :: Maybe Text
$sel:transitGatewayArn:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
$sel:coreNetworkId:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
$sel:tags:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe [Tag]
$sel:clientToken:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
coreNetworkId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
transitGatewayArn

instance Data.ToHeaders CreateTransitGatewayPeering where
  toHeaders :: CreateTransitGatewayPeering -> 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 CreateTransitGatewayPeering where
  toJSON :: CreateTransitGatewayPeering -> Value
toJSON CreateTransitGatewayPeering' {Maybe [Tag]
Maybe Text
Text
transitGatewayArn :: Text
coreNetworkId :: Text
tags :: Maybe [Tag]
clientToken :: Maybe Text
$sel:transitGatewayArn:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
$sel:coreNetworkId:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Text
$sel:tags:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe [Tag]
$sel:clientToken:CreateTransitGatewayPeering' :: CreateTransitGatewayPeering -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientToken" 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
clientToken,
            (Key
"Tags" 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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"CoreNetworkId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
coreNetworkId),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"TransitGatewayArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
transitGatewayArn)
          ]
      )

instance Data.ToPath CreateTransitGatewayPeering where
  toPath :: CreateTransitGatewayPeering -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/transit-gateway-peerings"

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

-- | /See:/ 'newCreateTransitGatewayPeeringResponse' smart constructor.
data CreateTransitGatewayPeeringResponse = CreateTransitGatewayPeeringResponse'
  { -- | Returns information about the transit gateway peering connection
    -- request.
    CreateTransitGatewayPeeringResponse -> Maybe TransitGatewayPeering
transitGatewayPeering :: Prelude.Maybe TransitGatewayPeering,
    -- | The response's http status code.
    CreateTransitGatewayPeeringResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateTransitGatewayPeeringResponse
-> CreateTransitGatewayPeeringResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransitGatewayPeeringResponse
-> CreateTransitGatewayPeeringResponse -> Bool
$c/= :: CreateTransitGatewayPeeringResponse
-> CreateTransitGatewayPeeringResponse -> Bool
== :: CreateTransitGatewayPeeringResponse
-> CreateTransitGatewayPeeringResponse -> Bool
$c== :: CreateTransitGatewayPeeringResponse
-> CreateTransitGatewayPeeringResponse -> Bool
Prelude.Eq, ReadPrec [CreateTransitGatewayPeeringResponse]
ReadPrec CreateTransitGatewayPeeringResponse
Int -> ReadS CreateTransitGatewayPeeringResponse
ReadS [CreateTransitGatewayPeeringResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransitGatewayPeeringResponse]
$creadListPrec :: ReadPrec [CreateTransitGatewayPeeringResponse]
readPrec :: ReadPrec CreateTransitGatewayPeeringResponse
$creadPrec :: ReadPrec CreateTransitGatewayPeeringResponse
readList :: ReadS [CreateTransitGatewayPeeringResponse]
$creadList :: ReadS [CreateTransitGatewayPeeringResponse]
readsPrec :: Int -> ReadS CreateTransitGatewayPeeringResponse
$creadsPrec :: Int -> ReadS CreateTransitGatewayPeeringResponse
Prelude.Read, Int -> CreateTransitGatewayPeeringResponse -> ShowS
[CreateTransitGatewayPeeringResponse] -> ShowS
CreateTransitGatewayPeeringResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransitGatewayPeeringResponse] -> ShowS
$cshowList :: [CreateTransitGatewayPeeringResponse] -> ShowS
show :: CreateTransitGatewayPeeringResponse -> String
$cshow :: CreateTransitGatewayPeeringResponse -> String
showsPrec :: Int -> CreateTransitGatewayPeeringResponse -> ShowS
$cshowsPrec :: Int -> CreateTransitGatewayPeeringResponse -> ShowS
Prelude.Show, forall x.
Rep CreateTransitGatewayPeeringResponse x
-> CreateTransitGatewayPeeringResponse
forall x.
CreateTransitGatewayPeeringResponse
-> Rep CreateTransitGatewayPeeringResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateTransitGatewayPeeringResponse x
-> CreateTransitGatewayPeeringResponse
$cfrom :: forall x.
CreateTransitGatewayPeeringResponse
-> Rep CreateTransitGatewayPeeringResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransitGatewayPeeringResponse' 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:
--
-- 'transitGatewayPeering', 'createTransitGatewayPeeringResponse_transitGatewayPeering' - Returns information about the transit gateway peering connection
-- request.
--
-- 'httpStatus', 'createTransitGatewayPeeringResponse_httpStatus' - The response's http status code.
newCreateTransitGatewayPeeringResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateTransitGatewayPeeringResponse
newCreateTransitGatewayPeeringResponse :: Int -> CreateTransitGatewayPeeringResponse
newCreateTransitGatewayPeeringResponse Int
pHttpStatus_ =
  CreateTransitGatewayPeeringResponse'
    { $sel:transitGatewayPeering:CreateTransitGatewayPeeringResponse' :: Maybe TransitGatewayPeering
transitGatewayPeering =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateTransitGatewayPeeringResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Returns information about the transit gateway peering connection
-- request.
createTransitGatewayPeeringResponse_transitGatewayPeering :: Lens.Lens' CreateTransitGatewayPeeringResponse (Prelude.Maybe TransitGatewayPeering)
createTransitGatewayPeeringResponse_transitGatewayPeering :: Lens'
  CreateTransitGatewayPeeringResponse (Maybe TransitGatewayPeering)
createTransitGatewayPeeringResponse_transitGatewayPeering = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPeeringResponse' {Maybe TransitGatewayPeering
transitGatewayPeering :: Maybe TransitGatewayPeering
$sel:transitGatewayPeering:CreateTransitGatewayPeeringResponse' :: CreateTransitGatewayPeeringResponse -> Maybe TransitGatewayPeering
transitGatewayPeering} -> Maybe TransitGatewayPeering
transitGatewayPeering) (\s :: CreateTransitGatewayPeeringResponse
s@CreateTransitGatewayPeeringResponse' {} Maybe TransitGatewayPeering
a -> CreateTransitGatewayPeeringResponse
s {$sel:transitGatewayPeering:CreateTransitGatewayPeeringResponse' :: Maybe TransitGatewayPeering
transitGatewayPeering = Maybe TransitGatewayPeering
a} :: CreateTransitGatewayPeeringResponse)

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

instance
  Prelude.NFData
    CreateTransitGatewayPeeringResponse
  where
  rnf :: CreateTransitGatewayPeeringResponse -> ()
rnf CreateTransitGatewayPeeringResponse' {Int
Maybe TransitGatewayPeering
httpStatus :: Int
transitGatewayPeering :: Maybe TransitGatewayPeering
$sel:httpStatus:CreateTransitGatewayPeeringResponse' :: CreateTransitGatewayPeeringResponse -> Int
$sel:transitGatewayPeering:CreateTransitGatewayPeeringResponse' :: CreateTransitGatewayPeeringResponse -> Maybe TransitGatewayPeering
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe TransitGatewayPeering
transitGatewayPeering
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus