{-# 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.CreateEgressOnlyInternetGateway
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- [IPv6 only] Creates an egress-only internet gateway for your VPC. An
-- egress-only internet gateway is used to enable outbound communication
-- over IPv6 from instances in your VPC to the internet, and prevents hosts
-- outside of your VPC from initiating an IPv6 connection with your
-- instance.
module Amazonka.EC2.CreateEgressOnlyInternetGateway
  ( -- * Creating a Request
    CreateEgressOnlyInternetGateway (..),
    newCreateEgressOnlyInternetGateway,

    -- * Request Lenses
    createEgressOnlyInternetGateway_clientToken,
    createEgressOnlyInternetGateway_dryRun,
    createEgressOnlyInternetGateway_tagSpecifications,
    createEgressOnlyInternetGateway_vpcId,

    -- * Destructuring the Response
    CreateEgressOnlyInternetGatewayResponse (..),
    newCreateEgressOnlyInternetGatewayResponse,

    -- * Response Lenses
    createEgressOnlyInternetGatewayResponse_clientToken,
    createEgressOnlyInternetGatewayResponse_egressOnlyInternetGateway,
    createEgressOnlyInternetGatewayResponse_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:/ 'newCreateEgressOnlyInternetGateway' smart constructor.
data CreateEgressOnlyInternetGateway = CreateEgressOnlyInternetGateway'
  { -- | Unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request. For more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Run_Instance_Idempotency.html How to ensure idempotency>.
    CreateEgressOnlyInternetGateway -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | 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@.
    CreateEgressOnlyInternetGateway -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The tags to assign to the egress-only internet gateway.
    CreateEgressOnlyInternetGateway -> Maybe [TagSpecification]
tagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | The ID of the VPC for which to create the egress-only internet gateway.
    CreateEgressOnlyInternetGateway -> Text
vpcId :: Prelude.Text
  }
  deriving (CreateEgressOnlyInternetGateway
-> CreateEgressOnlyInternetGateway -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateEgressOnlyInternetGateway
-> CreateEgressOnlyInternetGateway -> Bool
$c/= :: CreateEgressOnlyInternetGateway
-> CreateEgressOnlyInternetGateway -> Bool
== :: CreateEgressOnlyInternetGateway
-> CreateEgressOnlyInternetGateway -> Bool
$c== :: CreateEgressOnlyInternetGateway
-> CreateEgressOnlyInternetGateway -> Bool
Prelude.Eq, ReadPrec [CreateEgressOnlyInternetGateway]
ReadPrec CreateEgressOnlyInternetGateway
Int -> ReadS CreateEgressOnlyInternetGateway
ReadS [CreateEgressOnlyInternetGateway]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateEgressOnlyInternetGateway]
$creadListPrec :: ReadPrec [CreateEgressOnlyInternetGateway]
readPrec :: ReadPrec CreateEgressOnlyInternetGateway
$creadPrec :: ReadPrec CreateEgressOnlyInternetGateway
readList :: ReadS [CreateEgressOnlyInternetGateway]
$creadList :: ReadS [CreateEgressOnlyInternetGateway]
readsPrec :: Int -> ReadS CreateEgressOnlyInternetGateway
$creadsPrec :: Int -> ReadS CreateEgressOnlyInternetGateway
Prelude.Read, Int -> CreateEgressOnlyInternetGateway -> ShowS
[CreateEgressOnlyInternetGateway] -> ShowS
CreateEgressOnlyInternetGateway -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateEgressOnlyInternetGateway] -> ShowS
$cshowList :: [CreateEgressOnlyInternetGateway] -> ShowS
show :: CreateEgressOnlyInternetGateway -> String
$cshow :: CreateEgressOnlyInternetGateway -> String
showsPrec :: Int -> CreateEgressOnlyInternetGateway -> ShowS
$cshowsPrec :: Int -> CreateEgressOnlyInternetGateway -> ShowS
Prelude.Show, forall x.
Rep CreateEgressOnlyInternetGateway x
-> CreateEgressOnlyInternetGateway
forall x.
CreateEgressOnlyInternetGateway
-> Rep CreateEgressOnlyInternetGateway x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateEgressOnlyInternetGateway x
-> CreateEgressOnlyInternetGateway
$cfrom :: forall x.
CreateEgressOnlyInternetGateway
-> Rep CreateEgressOnlyInternetGateway x
Prelude.Generic)

-- |
-- Create a value of 'CreateEgressOnlyInternetGateway' 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', 'createEgressOnlyInternetGateway_clientToken' - Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Run_Instance_Idempotency.html How to ensure idempotency>.
--
-- 'dryRun', 'createEgressOnlyInternetGateway_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', 'createEgressOnlyInternetGateway_tagSpecifications' - The tags to assign to the egress-only internet gateway.
--
-- 'vpcId', 'createEgressOnlyInternetGateway_vpcId' - The ID of the VPC for which to create the egress-only internet gateway.
newCreateEgressOnlyInternetGateway ::
  -- | 'vpcId'
  Prelude.Text ->
  CreateEgressOnlyInternetGateway
newCreateEgressOnlyInternetGateway :: Text -> CreateEgressOnlyInternetGateway
newCreateEgressOnlyInternetGateway Text
pVpcId_ =
  CreateEgressOnlyInternetGateway'
    { $sel:clientToken:CreateEgressOnlyInternetGateway' :: Maybe Text
clientToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:dryRun:CreateEgressOnlyInternetGateway' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:tagSpecifications:CreateEgressOnlyInternetGateway' :: Maybe [TagSpecification]
tagSpecifications = forall a. Maybe a
Prelude.Nothing,
      $sel:vpcId:CreateEgressOnlyInternetGateway' :: Text
vpcId = Text
pVpcId_
    }

-- | Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Run_Instance_Idempotency.html How to ensure idempotency>.
createEgressOnlyInternetGateway_clientToken :: Lens.Lens' CreateEgressOnlyInternetGateway (Prelude.Maybe Prelude.Text)
createEgressOnlyInternetGateway_clientToken :: Lens' CreateEgressOnlyInternetGateway (Maybe Text)
createEgressOnlyInternetGateway_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateEgressOnlyInternetGateway' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateEgressOnlyInternetGateway
s@CreateEgressOnlyInternetGateway' {} Maybe Text
a -> CreateEgressOnlyInternetGateway
s {$sel:clientToken:CreateEgressOnlyInternetGateway' :: Maybe Text
clientToken = Maybe Text
a} :: CreateEgressOnlyInternetGateway)

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

-- | The tags to assign to the egress-only internet gateway.
createEgressOnlyInternetGateway_tagSpecifications :: Lens.Lens' CreateEgressOnlyInternetGateway (Prelude.Maybe [TagSpecification])
createEgressOnlyInternetGateway_tagSpecifications :: Lens' CreateEgressOnlyInternetGateway (Maybe [TagSpecification])
createEgressOnlyInternetGateway_tagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateEgressOnlyInternetGateway' {Maybe [TagSpecification]
tagSpecifications :: Maybe [TagSpecification]
$sel:tagSpecifications:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Maybe [TagSpecification]
tagSpecifications} -> Maybe [TagSpecification]
tagSpecifications) (\s :: CreateEgressOnlyInternetGateway
s@CreateEgressOnlyInternetGateway' {} Maybe [TagSpecification]
a -> CreateEgressOnlyInternetGateway
s {$sel:tagSpecifications:CreateEgressOnlyInternetGateway' :: Maybe [TagSpecification]
tagSpecifications = Maybe [TagSpecification]
a} :: CreateEgressOnlyInternetGateway) 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 VPC for which to create the egress-only internet gateway.
createEgressOnlyInternetGateway_vpcId :: Lens.Lens' CreateEgressOnlyInternetGateway Prelude.Text
createEgressOnlyInternetGateway_vpcId :: Lens' CreateEgressOnlyInternetGateway Text
createEgressOnlyInternetGateway_vpcId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateEgressOnlyInternetGateway' {Text
vpcId :: Text
$sel:vpcId:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Text
vpcId} -> Text
vpcId) (\s :: CreateEgressOnlyInternetGateway
s@CreateEgressOnlyInternetGateway' {} Text
a -> CreateEgressOnlyInternetGateway
s {$sel:vpcId:CreateEgressOnlyInternetGateway' :: Text
vpcId = Text
a} :: CreateEgressOnlyInternetGateway)

instance
  Core.AWSRequest
    CreateEgressOnlyInternetGateway
  where
  type
    AWSResponse CreateEgressOnlyInternetGateway =
      CreateEgressOnlyInternetGatewayResponse
  request :: (Service -> Service)
-> CreateEgressOnlyInternetGateway
-> Request CreateEgressOnlyInternetGateway
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 CreateEgressOnlyInternetGateway
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateEgressOnlyInternetGateway)))
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 Text
-> Maybe EgressOnlyInternetGateway
-> Int
-> CreateEgressOnlyInternetGatewayResponse
CreateEgressOnlyInternetGatewayResponse'
            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
"clientToken")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"egressOnlyInternetGateway")
            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
    CreateEgressOnlyInternetGateway
  where
  hashWithSalt :: Int -> CreateEgressOnlyInternetGateway -> Int
hashWithSalt
    Int
_salt
    CreateEgressOnlyInternetGateway' {Maybe Bool
Maybe [TagSpecification]
Maybe Text
Text
vpcId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
clientToken :: Maybe Text
$sel:vpcId:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Text
$sel:tagSpecifications:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Maybe [TagSpecification]
$sel:dryRun:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Maybe Bool
$sel:clientToken:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> 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 Bool
dryRun
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TagSpecification]
tagSpecifications
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vpcId

instance
  Prelude.NFData
    CreateEgressOnlyInternetGateway
  where
  rnf :: CreateEgressOnlyInternetGateway -> ()
rnf CreateEgressOnlyInternetGateway' {Maybe Bool
Maybe [TagSpecification]
Maybe Text
Text
vpcId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
clientToken :: Maybe Text
$sel:vpcId:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Text
$sel:tagSpecifications:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Maybe [TagSpecification]
$sel:dryRun:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> Maybe Bool
$sel:clientToken:CreateEgressOnlyInternetGateway' :: CreateEgressOnlyInternetGateway -> 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 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
vpcId

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

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

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

-- | /See:/ 'newCreateEgressOnlyInternetGatewayResponse' smart constructor.
data CreateEgressOnlyInternetGatewayResponse = CreateEgressOnlyInternetGatewayResponse'
  { -- | Unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request.
    CreateEgressOnlyInternetGatewayResponse -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Information about the egress-only internet gateway.
    CreateEgressOnlyInternetGatewayResponse
-> Maybe EgressOnlyInternetGateway
egressOnlyInternetGateway :: Prelude.Maybe EgressOnlyInternetGateway,
    -- | The response's http status code.
    CreateEgressOnlyInternetGatewayResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateEgressOnlyInternetGatewayResponse
-> CreateEgressOnlyInternetGatewayResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateEgressOnlyInternetGatewayResponse
-> CreateEgressOnlyInternetGatewayResponse -> Bool
$c/= :: CreateEgressOnlyInternetGatewayResponse
-> CreateEgressOnlyInternetGatewayResponse -> Bool
== :: CreateEgressOnlyInternetGatewayResponse
-> CreateEgressOnlyInternetGatewayResponse -> Bool
$c== :: CreateEgressOnlyInternetGatewayResponse
-> CreateEgressOnlyInternetGatewayResponse -> Bool
Prelude.Eq, ReadPrec [CreateEgressOnlyInternetGatewayResponse]
ReadPrec CreateEgressOnlyInternetGatewayResponse
Int -> ReadS CreateEgressOnlyInternetGatewayResponse
ReadS [CreateEgressOnlyInternetGatewayResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateEgressOnlyInternetGatewayResponse]
$creadListPrec :: ReadPrec [CreateEgressOnlyInternetGatewayResponse]
readPrec :: ReadPrec CreateEgressOnlyInternetGatewayResponse
$creadPrec :: ReadPrec CreateEgressOnlyInternetGatewayResponse
readList :: ReadS [CreateEgressOnlyInternetGatewayResponse]
$creadList :: ReadS [CreateEgressOnlyInternetGatewayResponse]
readsPrec :: Int -> ReadS CreateEgressOnlyInternetGatewayResponse
$creadsPrec :: Int -> ReadS CreateEgressOnlyInternetGatewayResponse
Prelude.Read, Int -> CreateEgressOnlyInternetGatewayResponse -> ShowS
[CreateEgressOnlyInternetGatewayResponse] -> ShowS
CreateEgressOnlyInternetGatewayResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateEgressOnlyInternetGatewayResponse] -> ShowS
$cshowList :: [CreateEgressOnlyInternetGatewayResponse] -> ShowS
show :: CreateEgressOnlyInternetGatewayResponse -> String
$cshow :: CreateEgressOnlyInternetGatewayResponse -> String
showsPrec :: Int -> CreateEgressOnlyInternetGatewayResponse -> ShowS
$cshowsPrec :: Int -> CreateEgressOnlyInternetGatewayResponse -> ShowS
Prelude.Show, forall x.
Rep CreateEgressOnlyInternetGatewayResponse x
-> CreateEgressOnlyInternetGatewayResponse
forall x.
CreateEgressOnlyInternetGatewayResponse
-> Rep CreateEgressOnlyInternetGatewayResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateEgressOnlyInternetGatewayResponse x
-> CreateEgressOnlyInternetGatewayResponse
$cfrom :: forall x.
CreateEgressOnlyInternetGatewayResponse
-> Rep CreateEgressOnlyInternetGatewayResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateEgressOnlyInternetGatewayResponse' 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', 'createEgressOnlyInternetGatewayResponse_clientToken' - Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
--
-- 'egressOnlyInternetGateway', 'createEgressOnlyInternetGatewayResponse_egressOnlyInternetGateway' - Information about the egress-only internet gateway.
--
-- 'httpStatus', 'createEgressOnlyInternetGatewayResponse_httpStatus' - The response's http status code.
newCreateEgressOnlyInternetGatewayResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateEgressOnlyInternetGatewayResponse
newCreateEgressOnlyInternetGatewayResponse :: Int -> CreateEgressOnlyInternetGatewayResponse
newCreateEgressOnlyInternetGatewayResponse
  Int
pHttpStatus_ =
    CreateEgressOnlyInternetGatewayResponse'
      { $sel:clientToken:CreateEgressOnlyInternetGatewayResponse' :: Maybe Text
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:egressOnlyInternetGateway:CreateEgressOnlyInternetGatewayResponse' :: Maybe EgressOnlyInternetGateway
egressOnlyInternetGateway =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateEgressOnlyInternetGatewayResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
createEgressOnlyInternetGatewayResponse_clientToken :: Lens.Lens' CreateEgressOnlyInternetGatewayResponse (Prelude.Maybe Prelude.Text)
createEgressOnlyInternetGatewayResponse_clientToken :: Lens' CreateEgressOnlyInternetGatewayResponse (Maybe Text)
createEgressOnlyInternetGatewayResponse_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateEgressOnlyInternetGatewayResponse' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateEgressOnlyInternetGatewayResponse' :: CreateEgressOnlyInternetGatewayResponse -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateEgressOnlyInternetGatewayResponse
s@CreateEgressOnlyInternetGatewayResponse' {} Maybe Text
a -> CreateEgressOnlyInternetGatewayResponse
s {$sel:clientToken:CreateEgressOnlyInternetGatewayResponse' :: Maybe Text
clientToken = Maybe Text
a} :: CreateEgressOnlyInternetGatewayResponse)

-- | Information about the egress-only internet gateway.
createEgressOnlyInternetGatewayResponse_egressOnlyInternetGateway :: Lens.Lens' CreateEgressOnlyInternetGatewayResponse (Prelude.Maybe EgressOnlyInternetGateway)
createEgressOnlyInternetGatewayResponse_egressOnlyInternetGateway :: Lens'
  CreateEgressOnlyInternetGatewayResponse
  (Maybe EgressOnlyInternetGateway)
createEgressOnlyInternetGatewayResponse_egressOnlyInternetGateway = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateEgressOnlyInternetGatewayResponse' {Maybe EgressOnlyInternetGateway
egressOnlyInternetGateway :: Maybe EgressOnlyInternetGateway
$sel:egressOnlyInternetGateway:CreateEgressOnlyInternetGatewayResponse' :: CreateEgressOnlyInternetGatewayResponse
-> Maybe EgressOnlyInternetGateway
egressOnlyInternetGateway} -> Maybe EgressOnlyInternetGateway
egressOnlyInternetGateway) (\s :: CreateEgressOnlyInternetGatewayResponse
s@CreateEgressOnlyInternetGatewayResponse' {} Maybe EgressOnlyInternetGateway
a -> CreateEgressOnlyInternetGatewayResponse
s {$sel:egressOnlyInternetGateway:CreateEgressOnlyInternetGatewayResponse' :: Maybe EgressOnlyInternetGateway
egressOnlyInternetGateway = Maybe EgressOnlyInternetGateway
a} :: CreateEgressOnlyInternetGatewayResponse)

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

instance
  Prelude.NFData
    CreateEgressOnlyInternetGatewayResponse
  where
  rnf :: CreateEgressOnlyInternetGatewayResponse -> ()
rnf CreateEgressOnlyInternetGatewayResponse' {Int
Maybe Text
Maybe EgressOnlyInternetGateway
httpStatus :: Int
egressOnlyInternetGateway :: Maybe EgressOnlyInternetGateway
clientToken :: Maybe Text
$sel:httpStatus:CreateEgressOnlyInternetGatewayResponse' :: CreateEgressOnlyInternetGatewayResponse -> Int
$sel:egressOnlyInternetGateway:CreateEgressOnlyInternetGatewayResponse' :: CreateEgressOnlyInternetGatewayResponse
-> Maybe EgressOnlyInternetGateway
$sel:clientToken:CreateEgressOnlyInternetGatewayResponse' :: CreateEgressOnlyInternetGatewayResponse -> 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 EgressOnlyInternetGateway
egressOnlyInternetGateway
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus