{-# 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.EC2.CreateTransitGatewayConnectPeer
-- 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 Connect peer for a specified transit gateway Connect
-- attachment between a transit gateway and an appliance.
--
-- The peer address and transit gateway address must be the same IP address
-- family (IPv4 or IPv6).
--
-- For more information, see
-- <https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html#tgw-connect-peer Connect peers>
-- in the /Transit Gateways Guide/.
module Amazonka.EC2.CreateTransitGatewayConnectPeer
  ( -- * Creating a Request
    CreateTransitGatewayConnectPeer (..),
    newCreateTransitGatewayConnectPeer,

    -- * Request Lenses
    createTransitGatewayConnectPeer_bgpOptions,
    createTransitGatewayConnectPeer_dryRun,
    createTransitGatewayConnectPeer_tagSpecifications,
    createTransitGatewayConnectPeer_transitGatewayAddress,
    createTransitGatewayConnectPeer_transitGatewayAttachmentId,
    createTransitGatewayConnectPeer_peerAddress,
    createTransitGatewayConnectPeer_insideCidrBlocks,

    -- * Destructuring the Response
    CreateTransitGatewayConnectPeerResponse (..),
    newCreateTransitGatewayConnectPeerResponse,

    -- * Response Lenses
    createTransitGatewayConnectPeerResponse_transitGatewayConnectPeer,
    createTransitGatewayConnectPeerResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateTransitGatewayConnectPeer' smart constructor.
data CreateTransitGatewayConnectPeer = CreateTransitGatewayConnectPeer'
  { -- | The BGP options for the Connect peer.
    CreateTransitGatewayConnectPeer
-> Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions :: Prelude.Maybe TransitGatewayConnectRequestBgpOptions,
    -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    CreateTransitGatewayConnectPeer -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The tags to apply to the Connect peer.
    CreateTransitGatewayConnectPeer -> Maybe [TagSpecification]
tagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | The peer IP address (GRE outer IP address) on the transit gateway side
    -- of the Connect peer, which must be specified from a transit gateway CIDR
    -- block. If not specified, Amazon automatically assigns the first
    -- available IP address from the transit gateway CIDR block.
    CreateTransitGatewayConnectPeer -> Maybe Text
transitGatewayAddress :: Prelude.Maybe Prelude.Text,
    -- | The ID of the Connect attachment.
    CreateTransitGatewayConnectPeer -> Text
transitGatewayAttachmentId :: Prelude.Text,
    -- | The peer IP address (GRE outer IP address) on the appliance side of the
    -- Connect peer.
    CreateTransitGatewayConnectPeer -> Text
peerAddress :: Prelude.Text,
    -- | The range of inside IP addresses that are used for BGP peering. You must
    -- specify a size \/29 IPv4 CIDR block from the @169.254.0.0\/16@ range.
    -- The first address from the range must be configured on the appliance as
    -- the BGP IP address. You can also optionally specify a size \/125 IPv6
    -- CIDR block from the @fd00::\/8@ range.
    CreateTransitGatewayConnectPeer -> [Text]
insideCidrBlocks :: [Prelude.Text]
  }
  deriving (CreateTransitGatewayConnectPeer
-> CreateTransitGatewayConnectPeer -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransitGatewayConnectPeer
-> CreateTransitGatewayConnectPeer -> Bool
$c/= :: CreateTransitGatewayConnectPeer
-> CreateTransitGatewayConnectPeer -> Bool
== :: CreateTransitGatewayConnectPeer
-> CreateTransitGatewayConnectPeer -> Bool
$c== :: CreateTransitGatewayConnectPeer
-> CreateTransitGatewayConnectPeer -> Bool
Prelude.Eq, ReadPrec [CreateTransitGatewayConnectPeer]
ReadPrec CreateTransitGatewayConnectPeer
Int -> ReadS CreateTransitGatewayConnectPeer
ReadS [CreateTransitGatewayConnectPeer]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransitGatewayConnectPeer]
$creadListPrec :: ReadPrec [CreateTransitGatewayConnectPeer]
readPrec :: ReadPrec CreateTransitGatewayConnectPeer
$creadPrec :: ReadPrec CreateTransitGatewayConnectPeer
readList :: ReadS [CreateTransitGatewayConnectPeer]
$creadList :: ReadS [CreateTransitGatewayConnectPeer]
readsPrec :: Int -> ReadS CreateTransitGatewayConnectPeer
$creadsPrec :: Int -> ReadS CreateTransitGatewayConnectPeer
Prelude.Read, Int -> CreateTransitGatewayConnectPeer -> ShowS
[CreateTransitGatewayConnectPeer] -> ShowS
CreateTransitGatewayConnectPeer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransitGatewayConnectPeer] -> ShowS
$cshowList :: [CreateTransitGatewayConnectPeer] -> ShowS
show :: CreateTransitGatewayConnectPeer -> String
$cshow :: CreateTransitGatewayConnectPeer -> String
showsPrec :: Int -> CreateTransitGatewayConnectPeer -> ShowS
$cshowsPrec :: Int -> CreateTransitGatewayConnectPeer -> ShowS
Prelude.Show, forall x.
Rep CreateTransitGatewayConnectPeer x
-> CreateTransitGatewayConnectPeer
forall x.
CreateTransitGatewayConnectPeer
-> Rep CreateTransitGatewayConnectPeer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateTransitGatewayConnectPeer x
-> CreateTransitGatewayConnectPeer
$cfrom :: forall x.
CreateTransitGatewayConnectPeer
-> Rep CreateTransitGatewayConnectPeer x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransitGatewayConnectPeer' 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:
--
-- 'bgpOptions', 'createTransitGatewayConnectPeer_bgpOptions' - The BGP options for the Connect peer.
--
-- 'dryRun', 'createTransitGatewayConnectPeer_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'tagSpecifications', 'createTransitGatewayConnectPeer_tagSpecifications' - The tags to apply to the Connect peer.
--
-- 'transitGatewayAddress', 'createTransitGatewayConnectPeer_transitGatewayAddress' - The peer IP address (GRE outer IP address) on the transit gateway side
-- of the Connect peer, which must be specified from a transit gateway CIDR
-- block. If not specified, Amazon automatically assigns the first
-- available IP address from the transit gateway CIDR block.
--
-- 'transitGatewayAttachmentId', 'createTransitGatewayConnectPeer_transitGatewayAttachmentId' - The ID of the Connect attachment.
--
-- 'peerAddress', 'createTransitGatewayConnectPeer_peerAddress' - The peer IP address (GRE outer IP address) on the appliance side of the
-- Connect peer.
--
-- 'insideCidrBlocks', 'createTransitGatewayConnectPeer_insideCidrBlocks' - The range of inside IP addresses that are used for BGP peering. You must
-- specify a size \/29 IPv4 CIDR block from the @169.254.0.0\/16@ range.
-- The first address from the range must be configured on the appliance as
-- the BGP IP address. You can also optionally specify a size \/125 IPv6
-- CIDR block from the @fd00::\/8@ range.
newCreateTransitGatewayConnectPeer ::
  -- | 'transitGatewayAttachmentId'
  Prelude.Text ->
  -- | 'peerAddress'
  Prelude.Text ->
  CreateTransitGatewayConnectPeer
newCreateTransitGatewayConnectPeer :: Text -> Text -> CreateTransitGatewayConnectPeer
newCreateTransitGatewayConnectPeer
  Text
pTransitGatewayAttachmentId_
  Text
pPeerAddress_ =
    CreateTransitGatewayConnectPeer'
      { $sel:bgpOptions:CreateTransitGatewayConnectPeer' :: Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions =
          forall a. Maybe a
Prelude.Nothing,
        $sel:dryRun:CreateTransitGatewayConnectPeer' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
        $sel:tagSpecifications:CreateTransitGatewayConnectPeer' :: Maybe [TagSpecification]
tagSpecifications = forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayAddress:CreateTransitGatewayConnectPeer' :: Maybe Text
transitGatewayAddress = forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayAttachmentId:CreateTransitGatewayConnectPeer' :: Text
transitGatewayAttachmentId =
          Text
pTransitGatewayAttachmentId_,
        $sel:peerAddress:CreateTransitGatewayConnectPeer' :: Text
peerAddress = Text
pPeerAddress_,
        $sel:insideCidrBlocks:CreateTransitGatewayConnectPeer' :: [Text]
insideCidrBlocks = forall a. Monoid a => a
Prelude.mempty
      }

-- | The BGP options for the Connect peer.
createTransitGatewayConnectPeer_bgpOptions :: Lens.Lens' CreateTransitGatewayConnectPeer (Prelude.Maybe TransitGatewayConnectRequestBgpOptions)
createTransitGatewayConnectPeer_bgpOptions :: Lens'
  CreateTransitGatewayConnectPeer
  (Maybe TransitGatewayConnectRequestBgpOptions)
createTransitGatewayConnectPeer_bgpOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions :: Maybe TransitGatewayConnectRequestBgpOptions
$sel:bgpOptions:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer
-> Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions} -> Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} Maybe TransitGatewayConnectRequestBgpOptions
a -> CreateTransitGatewayConnectPeer
s {$sel:bgpOptions:CreateTransitGatewayConnectPeer' :: Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions = Maybe TransitGatewayConnectRequestBgpOptions
a} :: CreateTransitGatewayConnectPeer)

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
createTransitGatewayConnectPeer_dryRun :: Lens.Lens' CreateTransitGatewayConnectPeer (Prelude.Maybe Prelude.Bool)
createTransitGatewayConnectPeer_dryRun :: Lens' CreateTransitGatewayConnectPeer (Maybe Bool)
createTransitGatewayConnectPeer_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} Maybe Bool
a -> CreateTransitGatewayConnectPeer
s {$sel:dryRun:CreateTransitGatewayConnectPeer' :: Maybe Bool
dryRun = Maybe Bool
a} :: CreateTransitGatewayConnectPeer)

-- | The tags to apply to the Connect peer.
createTransitGatewayConnectPeer_tagSpecifications :: Lens.Lens' CreateTransitGatewayConnectPeer (Prelude.Maybe [TagSpecification])
createTransitGatewayConnectPeer_tagSpecifications :: Lens' CreateTransitGatewayConnectPeer (Maybe [TagSpecification])
createTransitGatewayConnectPeer_tagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {Maybe [TagSpecification]
tagSpecifications :: Maybe [TagSpecification]
$sel:tagSpecifications:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe [TagSpecification]
tagSpecifications} -> Maybe [TagSpecification]
tagSpecifications) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} Maybe [TagSpecification]
a -> CreateTransitGatewayConnectPeer
s {$sel:tagSpecifications:CreateTransitGatewayConnectPeer' :: Maybe [TagSpecification]
tagSpecifications = Maybe [TagSpecification]
a} :: CreateTransitGatewayConnectPeer) 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 peer IP address (GRE outer IP address) on the transit gateway side
-- of the Connect peer, which must be specified from a transit gateway CIDR
-- block. If not specified, Amazon automatically assigns the first
-- available IP address from the transit gateway CIDR block.
createTransitGatewayConnectPeer_transitGatewayAddress :: Lens.Lens' CreateTransitGatewayConnectPeer (Prelude.Maybe Prelude.Text)
createTransitGatewayConnectPeer_transitGatewayAddress :: Lens' CreateTransitGatewayConnectPeer (Maybe Text)
createTransitGatewayConnectPeer_transitGatewayAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {Maybe Text
transitGatewayAddress :: Maybe Text
$sel:transitGatewayAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Text
transitGatewayAddress} -> Maybe Text
transitGatewayAddress) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} Maybe Text
a -> CreateTransitGatewayConnectPeer
s {$sel:transitGatewayAddress:CreateTransitGatewayConnectPeer' :: Maybe Text
transitGatewayAddress = Maybe Text
a} :: CreateTransitGatewayConnectPeer)

-- | The ID of the Connect attachment.
createTransitGatewayConnectPeer_transitGatewayAttachmentId :: Lens.Lens' CreateTransitGatewayConnectPeer Prelude.Text
createTransitGatewayConnectPeer_transitGatewayAttachmentId :: Lens' CreateTransitGatewayConnectPeer Text
createTransitGatewayConnectPeer_transitGatewayAttachmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {Text
transitGatewayAttachmentId :: Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
transitGatewayAttachmentId} -> Text
transitGatewayAttachmentId) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} Text
a -> CreateTransitGatewayConnectPeer
s {$sel:transitGatewayAttachmentId:CreateTransitGatewayConnectPeer' :: Text
transitGatewayAttachmentId = Text
a} :: CreateTransitGatewayConnectPeer)

-- | The peer IP address (GRE outer IP address) on the appliance side of the
-- Connect peer.
createTransitGatewayConnectPeer_peerAddress :: Lens.Lens' CreateTransitGatewayConnectPeer Prelude.Text
createTransitGatewayConnectPeer_peerAddress :: Lens' CreateTransitGatewayConnectPeer Text
createTransitGatewayConnectPeer_peerAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {Text
peerAddress :: Text
$sel:peerAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
peerAddress} -> Text
peerAddress) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} Text
a -> CreateTransitGatewayConnectPeer
s {$sel:peerAddress:CreateTransitGatewayConnectPeer' :: Text
peerAddress = Text
a} :: CreateTransitGatewayConnectPeer)

-- | The range of inside IP addresses that are used for BGP peering. You must
-- specify a size \/29 IPv4 CIDR block from the @169.254.0.0\/16@ range.
-- The first address from the range must be configured on the appliance as
-- the BGP IP address. You can also optionally specify a size \/125 IPv6
-- CIDR block from the @fd00::\/8@ range.
createTransitGatewayConnectPeer_insideCidrBlocks :: Lens.Lens' CreateTransitGatewayConnectPeer [Prelude.Text]
createTransitGatewayConnectPeer_insideCidrBlocks :: Lens' CreateTransitGatewayConnectPeer [Text]
createTransitGatewayConnectPeer_insideCidrBlocks = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeer' {[Text]
insideCidrBlocks :: [Text]
$sel:insideCidrBlocks:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> [Text]
insideCidrBlocks} -> [Text]
insideCidrBlocks) (\s :: CreateTransitGatewayConnectPeer
s@CreateTransitGatewayConnectPeer' {} [Text]
a -> CreateTransitGatewayConnectPeer
s {$sel:insideCidrBlocks:CreateTransitGatewayConnectPeer' :: [Text]
insideCidrBlocks = [Text]
a} :: CreateTransitGatewayConnectPeer) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance
  Core.AWSRequest
    CreateTransitGatewayConnectPeer
  where
  type
    AWSResponse CreateTransitGatewayConnectPeer =
      CreateTransitGatewayConnectPeerResponse
  request :: (Service -> Service)
-> CreateTransitGatewayConnectPeer
-> Request CreateTransitGatewayConnectPeer
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateTransitGatewayConnectPeer
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateTransitGatewayConnectPeer)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe TransitGatewayConnectPeer
-> Int -> CreateTransitGatewayConnectPeerResponse
CreateTransitGatewayConnectPeerResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"transitGatewayConnectPeer")
            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
    CreateTransitGatewayConnectPeer
  where
  hashWithSalt :: Int -> CreateTransitGatewayConnectPeer -> Int
hashWithSalt
    Int
_salt
    CreateTransitGatewayConnectPeer' {[Text]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe TransitGatewayConnectRequestBgpOptions
Text
insideCidrBlocks :: [Text]
peerAddress :: Text
transitGatewayAttachmentId :: Text
transitGatewayAddress :: Maybe Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
bgpOptions :: Maybe TransitGatewayConnectRequestBgpOptions
$sel:insideCidrBlocks:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> [Text]
$sel:peerAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
$sel:transitGatewayAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Text
$sel:tagSpecifications:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe [TagSpecification]
$sel:dryRun:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Bool
$sel:bgpOptions:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer
-> Maybe TransitGatewayConnectRequestBgpOptions
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TagSpecification]
tagSpecifications
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
transitGatewayAddress
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
transitGatewayAttachmentId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
peerAddress
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
insideCidrBlocks

instance
  Prelude.NFData
    CreateTransitGatewayConnectPeer
  where
  rnf :: CreateTransitGatewayConnectPeer -> ()
rnf CreateTransitGatewayConnectPeer' {[Text]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe TransitGatewayConnectRequestBgpOptions
Text
insideCidrBlocks :: [Text]
peerAddress :: Text
transitGatewayAttachmentId :: Text
transitGatewayAddress :: Maybe Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
bgpOptions :: Maybe TransitGatewayConnectRequestBgpOptions
$sel:insideCidrBlocks:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> [Text]
$sel:peerAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
$sel:transitGatewayAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Text
$sel:tagSpecifications:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe [TagSpecification]
$sel:dryRun:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Bool
$sel:bgpOptions:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer
-> Maybe TransitGatewayConnectRequestBgpOptions
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TagSpecification]
tagSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
transitGatewayAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
transitGatewayAttachmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
peerAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
insideCidrBlocks

instance
  Data.ToHeaders
    CreateTransitGatewayConnectPeer
  where
  toHeaders :: CreateTransitGatewayConnectPeer -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery CreateTransitGatewayConnectPeer where
  toQuery :: CreateTransitGatewayConnectPeer -> QueryString
toQuery CreateTransitGatewayConnectPeer' {[Text]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe TransitGatewayConnectRequestBgpOptions
Text
insideCidrBlocks :: [Text]
peerAddress :: Text
transitGatewayAttachmentId :: Text
transitGatewayAddress :: Maybe Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
bgpOptions :: Maybe TransitGatewayConnectRequestBgpOptions
$sel:insideCidrBlocks:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> [Text]
$sel:peerAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Text
$sel:transitGatewayAddress:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Text
$sel:tagSpecifications:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe [TagSpecification]
$sel:dryRun:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer -> Maybe Bool
$sel:bgpOptions:CreateTransitGatewayConnectPeer' :: CreateTransitGatewayConnectPeer
-> Maybe TransitGatewayConnectRequestBgpOptions
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"CreateTransitGatewayConnectPeer" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"BgpOptions" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe TransitGatewayConnectRequestBgpOptions
bgpOptions,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"TagSpecification"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [TagSpecification]
tagSpecifications
          ),
        ByteString
"TransitGatewayAddress"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
transitGatewayAddress,
        ByteString
"TransitGatewayAttachmentId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
transitGatewayAttachmentId,
        ByteString
"PeerAddress" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
peerAddress,
        forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"InsideCidrBlocks" [Text]
insideCidrBlocks
      ]

-- | /See:/ 'newCreateTransitGatewayConnectPeerResponse' smart constructor.
data CreateTransitGatewayConnectPeerResponse = CreateTransitGatewayConnectPeerResponse'
  { -- | Information about the Connect peer.
    CreateTransitGatewayConnectPeerResponse
-> Maybe TransitGatewayConnectPeer
transitGatewayConnectPeer :: Prelude.Maybe TransitGatewayConnectPeer,
    -- | The response's http status code.
    CreateTransitGatewayConnectPeerResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateTransitGatewayConnectPeerResponse
-> CreateTransitGatewayConnectPeerResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransitGatewayConnectPeerResponse
-> CreateTransitGatewayConnectPeerResponse -> Bool
$c/= :: CreateTransitGatewayConnectPeerResponse
-> CreateTransitGatewayConnectPeerResponse -> Bool
== :: CreateTransitGatewayConnectPeerResponse
-> CreateTransitGatewayConnectPeerResponse -> Bool
$c== :: CreateTransitGatewayConnectPeerResponse
-> CreateTransitGatewayConnectPeerResponse -> Bool
Prelude.Eq, ReadPrec [CreateTransitGatewayConnectPeerResponse]
ReadPrec CreateTransitGatewayConnectPeerResponse
Int -> ReadS CreateTransitGatewayConnectPeerResponse
ReadS [CreateTransitGatewayConnectPeerResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransitGatewayConnectPeerResponse]
$creadListPrec :: ReadPrec [CreateTransitGatewayConnectPeerResponse]
readPrec :: ReadPrec CreateTransitGatewayConnectPeerResponse
$creadPrec :: ReadPrec CreateTransitGatewayConnectPeerResponse
readList :: ReadS [CreateTransitGatewayConnectPeerResponse]
$creadList :: ReadS [CreateTransitGatewayConnectPeerResponse]
readsPrec :: Int -> ReadS CreateTransitGatewayConnectPeerResponse
$creadsPrec :: Int -> ReadS CreateTransitGatewayConnectPeerResponse
Prelude.Read, Int -> CreateTransitGatewayConnectPeerResponse -> ShowS
[CreateTransitGatewayConnectPeerResponse] -> ShowS
CreateTransitGatewayConnectPeerResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransitGatewayConnectPeerResponse] -> ShowS
$cshowList :: [CreateTransitGatewayConnectPeerResponse] -> ShowS
show :: CreateTransitGatewayConnectPeerResponse -> String
$cshow :: CreateTransitGatewayConnectPeerResponse -> String
showsPrec :: Int -> CreateTransitGatewayConnectPeerResponse -> ShowS
$cshowsPrec :: Int -> CreateTransitGatewayConnectPeerResponse -> ShowS
Prelude.Show, forall x.
Rep CreateTransitGatewayConnectPeerResponse x
-> CreateTransitGatewayConnectPeerResponse
forall x.
CreateTransitGatewayConnectPeerResponse
-> Rep CreateTransitGatewayConnectPeerResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateTransitGatewayConnectPeerResponse x
-> CreateTransitGatewayConnectPeerResponse
$cfrom :: forall x.
CreateTransitGatewayConnectPeerResponse
-> Rep CreateTransitGatewayConnectPeerResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransitGatewayConnectPeerResponse' 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:
--
-- 'transitGatewayConnectPeer', 'createTransitGatewayConnectPeerResponse_transitGatewayConnectPeer' - Information about the Connect peer.
--
-- 'httpStatus', 'createTransitGatewayConnectPeerResponse_httpStatus' - The response's http status code.
newCreateTransitGatewayConnectPeerResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateTransitGatewayConnectPeerResponse
newCreateTransitGatewayConnectPeerResponse :: Int -> CreateTransitGatewayConnectPeerResponse
newCreateTransitGatewayConnectPeerResponse
  Int
pHttpStatus_ =
    CreateTransitGatewayConnectPeerResponse'
      { $sel:transitGatewayConnectPeer:CreateTransitGatewayConnectPeerResponse' :: Maybe TransitGatewayConnectPeer
transitGatewayConnectPeer =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateTransitGatewayConnectPeerResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Information about the Connect peer.
createTransitGatewayConnectPeerResponse_transitGatewayConnectPeer :: Lens.Lens' CreateTransitGatewayConnectPeerResponse (Prelude.Maybe TransitGatewayConnectPeer)
createTransitGatewayConnectPeerResponse_transitGatewayConnectPeer :: Lens'
  CreateTransitGatewayConnectPeerResponse
  (Maybe TransitGatewayConnectPeer)
createTransitGatewayConnectPeerResponse_transitGatewayConnectPeer = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectPeerResponse' {Maybe TransitGatewayConnectPeer
transitGatewayConnectPeer :: Maybe TransitGatewayConnectPeer
$sel:transitGatewayConnectPeer:CreateTransitGatewayConnectPeerResponse' :: CreateTransitGatewayConnectPeerResponse
-> Maybe TransitGatewayConnectPeer
transitGatewayConnectPeer} -> Maybe TransitGatewayConnectPeer
transitGatewayConnectPeer) (\s :: CreateTransitGatewayConnectPeerResponse
s@CreateTransitGatewayConnectPeerResponse' {} Maybe TransitGatewayConnectPeer
a -> CreateTransitGatewayConnectPeerResponse
s {$sel:transitGatewayConnectPeer:CreateTransitGatewayConnectPeerResponse' :: Maybe TransitGatewayConnectPeer
transitGatewayConnectPeer = Maybe TransitGatewayConnectPeer
a} :: CreateTransitGatewayConnectPeerResponse)

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

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