{-# 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.CreateTransitGatewayConnect
-- 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 attachment from a specified transit gateway
-- attachment. A Connect attachment is a GRE-based tunnel attachment that
-- you can use to establish a connection between a transit gateway and an
-- appliance.
--
-- A Connect attachment uses an existing VPC or Amazon Web Services Direct
-- Connect attachment as the underlying transport mechanism.
module Amazonka.EC2.CreateTransitGatewayConnect
  ( -- * Creating a Request
    CreateTransitGatewayConnect (..),
    newCreateTransitGatewayConnect,

    -- * Request Lenses
    createTransitGatewayConnect_dryRun,
    createTransitGatewayConnect_tagSpecifications,
    createTransitGatewayConnect_transportTransitGatewayAttachmentId,
    createTransitGatewayConnect_options,

    -- * Destructuring the Response
    CreateTransitGatewayConnectResponse (..),
    newCreateTransitGatewayConnectResponse,

    -- * Response Lenses
    createTransitGatewayConnectResponse_transitGatewayConnect,
    createTransitGatewayConnectResponse_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:/ 'newCreateTransitGatewayConnect' smart constructor.
data CreateTransitGatewayConnect = CreateTransitGatewayConnect'
  { -- | 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@.
    CreateTransitGatewayConnect -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The tags to apply to the Connect attachment.
    CreateTransitGatewayConnect -> Maybe [TagSpecification]
tagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | The ID of the transit gateway attachment. You can specify a VPC
    -- attachment or Amazon Web Services Direct Connect attachment.
    CreateTransitGatewayConnect -> Text
transportTransitGatewayAttachmentId :: Prelude.Text,
    -- | The Connect attachment options.
    CreateTransitGatewayConnect
-> CreateTransitGatewayConnectRequestOptions
options :: CreateTransitGatewayConnectRequestOptions
  }
  deriving (CreateTransitGatewayConnect -> CreateTransitGatewayConnect -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransitGatewayConnect -> CreateTransitGatewayConnect -> Bool
$c/= :: CreateTransitGatewayConnect -> CreateTransitGatewayConnect -> Bool
== :: CreateTransitGatewayConnect -> CreateTransitGatewayConnect -> Bool
$c== :: CreateTransitGatewayConnect -> CreateTransitGatewayConnect -> Bool
Prelude.Eq, ReadPrec [CreateTransitGatewayConnect]
ReadPrec CreateTransitGatewayConnect
Int -> ReadS CreateTransitGatewayConnect
ReadS [CreateTransitGatewayConnect]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransitGatewayConnect]
$creadListPrec :: ReadPrec [CreateTransitGatewayConnect]
readPrec :: ReadPrec CreateTransitGatewayConnect
$creadPrec :: ReadPrec CreateTransitGatewayConnect
readList :: ReadS [CreateTransitGatewayConnect]
$creadList :: ReadS [CreateTransitGatewayConnect]
readsPrec :: Int -> ReadS CreateTransitGatewayConnect
$creadsPrec :: Int -> ReadS CreateTransitGatewayConnect
Prelude.Read, Int -> CreateTransitGatewayConnect -> ShowS
[CreateTransitGatewayConnect] -> ShowS
CreateTransitGatewayConnect -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransitGatewayConnect] -> ShowS
$cshowList :: [CreateTransitGatewayConnect] -> ShowS
show :: CreateTransitGatewayConnect -> String
$cshow :: CreateTransitGatewayConnect -> String
showsPrec :: Int -> CreateTransitGatewayConnect -> ShowS
$cshowsPrec :: Int -> CreateTransitGatewayConnect -> ShowS
Prelude.Show, forall x.
Rep CreateTransitGatewayConnect x -> CreateTransitGatewayConnect
forall x.
CreateTransitGatewayConnect -> Rep CreateTransitGatewayConnect x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateTransitGatewayConnect x -> CreateTransitGatewayConnect
$cfrom :: forall x.
CreateTransitGatewayConnect -> Rep CreateTransitGatewayConnect x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransitGatewayConnect' 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:
--
-- 'dryRun', 'createTransitGatewayConnect_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', 'createTransitGatewayConnect_tagSpecifications' - The tags to apply to the Connect attachment.
--
-- 'transportTransitGatewayAttachmentId', 'createTransitGatewayConnect_transportTransitGatewayAttachmentId' - The ID of the transit gateway attachment. You can specify a VPC
-- attachment or Amazon Web Services Direct Connect attachment.
--
-- 'options', 'createTransitGatewayConnect_options' - The Connect attachment options.
newCreateTransitGatewayConnect ::
  -- | 'transportTransitGatewayAttachmentId'
  Prelude.Text ->
  -- | 'options'
  CreateTransitGatewayConnectRequestOptions ->
  CreateTransitGatewayConnect
newCreateTransitGatewayConnect :: Text
-> CreateTransitGatewayConnectRequestOptions
-> CreateTransitGatewayConnect
newCreateTransitGatewayConnect
  Text
pTransportTransitGatewayAttachmentId_
  CreateTransitGatewayConnectRequestOptions
pOptions_ =
    CreateTransitGatewayConnect'
      { $sel:dryRun:CreateTransitGatewayConnect' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tagSpecifications:CreateTransitGatewayConnect' :: Maybe [TagSpecification]
tagSpecifications = forall a. Maybe a
Prelude.Nothing,
        $sel:transportTransitGatewayAttachmentId:CreateTransitGatewayConnect' :: Text
transportTransitGatewayAttachmentId =
          Text
pTransportTransitGatewayAttachmentId_,
        $sel:options:CreateTransitGatewayConnect' :: CreateTransitGatewayConnectRequestOptions
options = CreateTransitGatewayConnectRequestOptions
pOptions_
      }

-- | 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@.
createTransitGatewayConnect_dryRun :: Lens.Lens' CreateTransitGatewayConnect (Prelude.Maybe Prelude.Bool)
createTransitGatewayConnect_dryRun :: Lens' CreateTransitGatewayConnect (Maybe Bool)
createTransitGatewayConnect_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnect' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: CreateTransitGatewayConnect
s@CreateTransitGatewayConnect' {} Maybe Bool
a -> CreateTransitGatewayConnect
s {$sel:dryRun:CreateTransitGatewayConnect' :: Maybe Bool
dryRun = Maybe Bool
a} :: CreateTransitGatewayConnect)

-- | The tags to apply to the Connect attachment.
createTransitGatewayConnect_tagSpecifications :: Lens.Lens' CreateTransitGatewayConnect (Prelude.Maybe [TagSpecification])
createTransitGatewayConnect_tagSpecifications :: Lens' CreateTransitGatewayConnect (Maybe [TagSpecification])
createTransitGatewayConnect_tagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnect' {Maybe [TagSpecification]
tagSpecifications :: Maybe [TagSpecification]
$sel:tagSpecifications:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe [TagSpecification]
tagSpecifications} -> Maybe [TagSpecification]
tagSpecifications) (\s :: CreateTransitGatewayConnect
s@CreateTransitGatewayConnect' {} Maybe [TagSpecification]
a -> CreateTransitGatewayConnect
s {$sel:tagSpecifications:CreateTransitGatewayConnect' :: Maybe [TagSpecification]
tagSpecifications = Maybe [TagSpecification]
a} :: CreateTransitGatewayConnect) 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 the transit gateway attachment. You can specify a VPC
-- attachment or Amazon Web Services Direct Connect attachment.
createTransitGatewayConnect_transportTransitGatewayAttachmentId :: Lens.Lens' CreateTransitGatewayConnect Prelude.Text
createTransitGatewayConnect_transportTransitGatewayAttachmentId :: Lens' CreateTransitGatewayConnect Text
createTransitGatewayConnect_transportTransitGatewayAttachmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnect' {Text
transportTransitGatewayAttachmentId :: Text
$sel:transportTransitGatewayAttachmentId:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Text
transportTransitGatewayAttachmentId} -> Text
transportTransitGatewayAttachmentId) (\s :: CreateTransitGatewayConnect
s@CreateTransitGatewayConnect' {} Text
a -> CreateTransitGatewayConnect
s {$sel:transportTransitGatewayAttachmentId:CreateTransitGatewayConnect' :: Text
transportTransitGatewayAttachmentId = Text
a} :: CreateTransitGatewayConnect)

-- | The Connect attachment options.
createTransitGatewayConnect_options :: Lens.Lens' CreateTransitGatewayConnect CreateTransitGatewayConnectRequestOptions
createTransitGatewayConnect_options :: Lens'
  CreateTransitGatewayConnect
  CreateTransitGatewayConnectRequestOptions
createTransitGatewayConnect_options = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnect' {CreateTransitGatewayConnectRequestOptions
options :: CreateTransitGatewayConnectRequestOptions
$sel:options:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect
-> CreateTransitGatewayConnectRequestOptions
options} -> CreateTransitGatewayConnectRequestOptions
options) (\s :: CreateTransitGatewayConnect
s@CreateTransitGatewayConnect' {} CreateTransitGatewayConnectRequestOptions
a -> CreateTransitGatewayConnect
s {$sel:options:CreateTransitGatewayConnect' :: CreateTransitGatewayConnectRequestOptions
options = CreateTransitGatewayConnectRequestOptions
a} :: CreateTransitGatewayConnect)

instance Core.AWSRequest CreateTransitGatewayConnect where
  type
    AWSResponse CreateTransitGatewayConnect =
      CreateTransitGatewayConnectResponse
  request :: (Service -> Service)
-> CreateTransitGatewayConnect
-> Request CreateTransitGatewayConnect
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 CreateTransitGatewayConnect
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateTransitGatewayConnect)))
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 TransitGatewayConnect
-> Int -> CreateTransitGatewayConnectResponse
CreateTransitGatewayConnectResponse'
            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
"transitGatewayConnect")
            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 CreateTransitGatewayConnect where
  hashWithSalt :: Int -> CreateTransitGatewayConnect -> Int
hashWithSalt Int
_salt CreateTransitGatewayConnect' {Maybe Bool
Maybe [TagSpecification]
Text
CreateTransitGatewayConnectRequestOptions
options :: CreateTransitGatewayConnectRequestOptions
transportTransitGatewayAttachmentId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
$sel:options:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect
-> CreateTransitGatewayConnectRequestOptions
$sel:transportTransitGatewayAttachmentId:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Text
$sel:tagSpecifications:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe [TagSpecification]
$sel:dryRun:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe Bool
..} =
    Int
_salt
      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` Text
transportTransitGatewayAttachmentId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` CreateTransitGatewayConnectRequestOptions
options

instance Prelude.NFData CreateTransitGatewayConnect where
  rnf :: CreateTransitGatewayConnect -> ()
rnf CreateTransitGatewayConnect' {Maybe Bool
Maybe [TagSpecification]
Text
CreateTransitGatewayConnectRequestOptions
options :: CreateTransitGatewayConnectRequestOptions
transportTransitGatewayAttachmentId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
$sel:options:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect
-> CreateTransitGatewayConnectRequestOptions
$sel:transportTransitGatewayAttachmentId:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Text
$sel:tagSpecifications:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe [TagSpecification]
$sel:dryRun:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe Bool
..} =
    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 Text
transportTransitGatewayAttachmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf CreateTransitGatewayConnectRequestOptions
options

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

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

instance Data.ToQuery CreateTransitGatewayConnect where
  toQuery :: CreateTransitGatewayConnect -> QueryString
toQuery CreateTransitGatewayConnect' {Maybe Bool
Maybe [TagSpecification]
Text
CreateTransitGatewayConnectRequestOptions
options :: CreateTransitGatewayConnectRequestOptions
transportTransitGatewayAttachmentId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
$sel:options:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect
-> CreateTransitGatewayConnectRequestOptions
$sel:transportTransitGatewayAttachmentId:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Text
$sel:tagSpecifications:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe [TagSpecification]
$sel:dryRun:CreateTransitGatewayConnect' :: CreateTransitGatewayConnect -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"CreateTransitGatewayConnect" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        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
"TransportTransitGatewayAttachmentId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
transportTransitGatewayAttachmentId,
        ByteString
"Options" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: CreateTransitGatewayConnectRequestOptions
options
      ]

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

-- |
-- Create a value of 'CreateTransitGatewayConnectResponse' 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:
--
-- 'transitGatewayConnect', 'createTransitGatewayConnectResponse_transitGatewayConnect' - Information about the Connect attachment.
--
-- 'httpStatus', 'createTransitGatewayConnectResponse_httpStatus' - The response's http status code.
newCreateTransitGatewayConnectResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateTransitGatewayConnectResponse
newCreateTransitGatewayConnectResponse :: Int -> CreateTransitGatewayConnectResponse
newCreateTransitGatewayConnectResponse Int
pHttpStatus_ =
  CreateTransitGatewayConnectResponse'
    { $sel:transitGatewayConnect:CreateTransitGatewayConnectResponse' :: Maybe TransitGatewayConnect
transitGatewayConnect =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateTransitGatewayConnectResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the Connect attachment.
createTransitGatewayConnectResponse_transitGatewayConnect :: Lens.Lens' CreateTransitGatewayConnectResponse (Prelude.Maybe TransitGatewayConnect)
createTransitGatewayConnectResponse_transitGatewayConnect :: Lens'
  CreateTransitGatewayConnectResponse (Maybe TransitGatewayConnect)
createTransitGatewayConnectResponse_transitGatewayConnect = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayConnectResponse' {Maybe TransitGatewayConnect
transitGatewayConnect :: Maybe TransitGatewayConnect
$sel:transitGatewayConnect:CreateTransitGatewayConnectResponse' :: CreateTransitGatewayConnectResponse -> Maybe TransitGatewayConnect
transitGatewayConnect} -> Maybe TransitGatewayConnect
transitGatewayConnect) (\s :: CreateTransitGatewayConnectResponse
s@CreateTransitGatewayConnectResponse' {} Maybe TransitGatewayConnect
a -> CreateTransitGatewayConnectResponse
s {$sel:transitGatewayConnect:CreateTransitGatewayConnectResponse' :: Maybe TransitGatewayConnect
transitGatewayConnect = Maybe TransitGatewayConnect
a} :: CreateTransitGatewayConnectResponse)

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

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