{-# 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.CreateTransitGatewayPrefixListReference
-- 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 reference (route) to a prefix list in a specified transit
-- gateway route table.
module Amazonka.EC2.CreateTransitGatewayPrefixListReference
  ( -- * Creating a Request
    CreateTransitGatewayPrefixListReference (..),
    newCreateTransitGatewayPrefixListReference,

    -- * Request Lenses
    createTransitGatewayPrefixListReference_blackhole,
    createTransitGatewayPrefixListReference_dryRun,
    createTransitGatewayPrefixListReference_transitGatewayAttachmentId,
    createTransitGatewayPrefixListReference_transitGatewayRouteTableId,
    createTransitGatewayPrefixListReference_prefixListId,

    -- * Destructuring the Response
    CreateTransitGatewayPrefixListReferenceResponse (..),
    newCreateTransitGatewayPrefixListReferenceResponse,

    -- * Response Lenses
    createTransitGatewayPrefixListReferenceResponse_transitGatewayPrefixListReference,
    createTransitGatewayPrefixListReferenceResponse_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:/ 'newCreateTransitGatewayPrefixListReference' smart constructor.
data CreateTransitGatewayPrefixListReference = CreateTransitGatewayPrefixListReference'
  { -- | Indicates whether to drop traffic that matches this route.
    CreateTransitGatewayPrefixListReference -> Maybe Bool
blackhole :: Prelude.Maybe Prelude.Bool,
    -- | 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@.
    CreateTransitGatewayPrefixListReference -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the attachment to which traffic is routed.
    CreateTransitGatewayPrefixListReference -> Maybe Text
transitGatewayAttachmentId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the transit gateway route table.
    CreateTransitGatewayPrefixListReference -> Text
transitGatewayRouteTableId :: Prelude.Text,
    -- | The ID of the prefix list that is used for destination matches.
    CreateTransitGatewayPrefixListReference -> Text
prefixListId :: Prelude.Text
  }
  deriving (CreateTransitGatewayPrefixListReference
-> CreateTransitGatewayPrefixListReference -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTransitGatewayPrefixListReference
-> CreateTransitGatewayPrefixListReference -> Bool
$c/= :: CreateTransitGatewayPrefixListReference
-> CreateTransitGatewayPrefixListReference -> Bool
== :: CreateTransitGatewayPrefixListReference
-> CreateTransitGatewayPrefixListReference -> Bool
$c== :: CreateTransitGatewayPrefixListReference
-> CreateTransitGatewayPrefixListReference -> Bool
Prelude.Eq, ReadPrec [CreateTransitGatewayPrefixListReference]
ReadPrec CreateTransitGatewayPrefixListReference
Int -> ReadS CreateTransitGatewayPrefixListReference
ReadS [CreateTransitGatewayPrefixListReference]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTransitGatewayPrefixListReference]
$creadListPrec :: ReadPrec [CreateTransitGatewayPrefixListReference]
readPrec :: ReadPrec CreateTransitGatewayPrefixListReference
$creadPrec :: ReadPrec CreateTransitGatewayPrefixListReference
readList :: ReadS [CreateTransitGatewayPrefixListReference]
$creadList :: ReadS [CreateTransitGatewayPrefixListReference]
readsPrec :: Int -> ReadS CreateTransitGatewayPrefixListReference
$creadsPrec :: Int -> ReadS CreateTransitGatewayPrefixListReference
Prelude.Read, Int -> CreateTransitGatewayPrefixListReference -> ShowS
[CreateTransitGatewayPrefixListReference] -> ShowS
CreateTransitGatewayPrefixListReference -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTransitGatewayPrefixListReference] -> ShowS
$cshowList :: [CreateTransitGatewayPrefixListReference] -> ShowS
show :: CreateTransitGatewayPrefixListReference -> String
$cshow :: CreateTransitGatewayPrefixListReference -> String
showsPrec :: Int -> CreateTransitGatewayPrefixListReference -> ShowS
$cshowsPrec :: Int -> CreateTransitGatewayPrefixListReference -> ShowS
Prelude.Show, forall x.
Rep CreateTransitGatewayPrefixListReference x
-> CreateTransitGatewayPrefixListReference
forall x.
CreateTransitGatewayPrefixListReference
-> Rep CreateTransitGatewayPrefixListReference x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateTransitGatewayPrefixListReference x
-> CreateTransitGatewayPrefixListReference
$cfrom :: forall x.
CreateTransitGatewayPrefixListReference
-> Rep CreateTransitGatewayPrefixListReference x
Prelude.Generic)

-- |
-- Create a value of 'CreateTransitGatewayPrefixListReference' 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:
--
-- 'blackhole', 'createTransitGatewayPrefixListReference_blackhole' - Indicates whether to drop traffic that matches this route.
--
-- 'dryRun', 'createTransitGatewayPrefixListReference_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@.
--
-- 'transitGatewayAttachmentId', 'createTransitGatewayPrefixListReference_transitGatewayAttachmentId' - The ID of the attachment to which traffic is routed.
--
-- 'transitGatewayRouteTableId', 'createTransitGatewayPrefixListReference_transitGatewayRouteTableId' - The ID of the transit gateway route table.
--
-- 'prefixListId', 'createTransitGatewayPrefixListReference_prefixListId' - The ID of the prefix list that is used for destination matches.
newCreateTransitGatewayPrefixListReference ::
  -- | 'transitGatewayRouteTableId'
  Prelude.Text ->
  -- | 'prefixListId'
  Prelude.Text ->
  CreateTransitGatewayPrefixListReference
newCreateTransitGatewayPrefixListReference :: Text -> Text -> CreateTransitGatewayPrefixListReference
newCreateTransitGatewayPrefixListReference
  Text
pTransitGatewayRouteTableId_
  Text
pPrefixListId_ =
    CreateTransitGatewayPrefixListReference'
      { $sel:blackhole:CreateTransitGatewayPrefixListReference' :: Maybe Bool
blackhole =
          forall a. Maybe a
Prelude.Nothing,
        $sel:dryRun:CreateTransitGatewayPrefixListReference' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayAttachmentId:CreateTransitGatewayPrefixListReference' :: Maybe Text
transitGatewayAttachmentId =
          forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayRouteTableId:CreateTransitGatewayPrefixListReference' :: Text
transitGatewayRouteTableId =
          Text
pTransitGatewayRouteTableId_,
        $sel:prefixListId:CreateTransitGatewayPrefixListReference' :: Text
prefixListId = Text
pPrefixListId_
      }

-- | Indicates whether to drop traffic that matches this route.
createTransitGatewayPrefixListReference_blackhole :: Lens.Lens' CreateTransitGatewayPrefixListReference (Prelude.Maybe Prelude.Bool)
createTransitGatewayPrefixListReference_blackhole :: Lens' CreateTransitGatewayPrefixListReference (Maybe Bool)
createTransitGatewayPrefixListReference_blackhole = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPrefixListReference' {Maybe Bool
blackhole :: Maybe Bool
$sel:blackhole:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
blackhole} -> Maybe Bool
blackhole) (\s :: CreateTransitGatewayPrefixListReference
s@CreateTransitGatewayPrefixListReference' {} Maybe Bool
a -> CreateTransitGatewayPrefixListReference
s {$sel:blackhole:CreateTransitGatewayPrefixListReference' :: Maybe Bool
blackhole = Maybe Bool
a} :: CreateTransitGatewayPrefixListReference)

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

-- | The ID of the attachment to which traffic is routed.
createTransitGatewayPrefixListReference_transitGatewayAttachmentId :: Lens.Lens' CreateTransitGatewayPrefixListReference (Prelude.Maybe Prelude.Text)
createTransitGatewayPrefixListReference_transitGatewayAttachmentId :: Lens' CreateTransitGatewayPrefixListReference (Maybe Text)
createTransitGatewayPrefixListReference_transitGatewayAttachmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPrefixListReference' {Maybe Text
transitGatewayAttachmentId :: Maybe Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Text
transitGatewayAttachmentId} -> Maybe Text
transitGatewayAttachmentId) (\s :: CreateTransitGatewayPrefixListReference
s@CreateTransitGatewayPrefixListReference' {} Maybe Text
a -> CreateTransitGatewayPrefixListReference
s {$sel:transitGatewayAttachmentId:CreateTransitGatewayPrefixListReference' :: Maybe Text
transitGatewayAttachmentId = Maybe Text
a} :: CreateTransitGatewayPrefixListReference)

-- | The ID of the transit gateway route table.
createTransitGatewayPrefixListReference_transitGatewayRouteTableId :: Lens.Lens' CreateTransitGatewayPrefixListReference Prelude.Text
createTransitGatewayPrefixListReference_transitGatewayRouteTableId :: Lens' CreateTransitGatewayPrefixListReference Text
createTransitGatewayPrefixListReference_transitGatewayRouteTableId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPrefixListReference' {Text
transitGatewayRouteTableId :: Text
$sel:transitGatewayRouteTableId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
transitGatewayRouteTableId} -> Text
transitGatewayRouteTableId) (\s :: CreateTransitGatewayPrefixListReference
s@CreateTransitGatewayPrefixListReference' {} Text
a -> CreateTransitGatewayPrefixListReference
s {$sel:transitGatewayRouteTableId:CreateTransitGatewayPrefixListReference' :: Text
transitGatewayRouteTableId = Text
a} :: CreateTransitGatewayPrefixListReference)

-- | The ID of the prefix list that is used for destination matches.
createTransitGatewayPrefixListReference_prefixListId :: Lens.Lens' CreateTransitGatewayPrefixListReference Prelude.Text
createTransitGatewayPrefixListReference_prefixListId :: Lens' CreateTransitGatewayPrefixListReference Text
createTransitGatewayPrefixListReference_prefixListId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPrefixListReference' {Text
prefixListId :: Text
$sel:prefixListId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
prefixListId} -> Text
prefixListId) (\s :: CreateTransitGatewayPrefixListReference
s@CreateTransitGatewayPrefixListReference' {} Text
a -> CreateTransitGatewayPrefixListReference
s {$sel:prefixListId:CreateTransitGatewayPrefixListReference' :: Text
prefixListId = Text
a} :: CreateTransitGatewayPrefixListReference)

instance
  Core.AWSRequest
    CreateTransitGatewayPrefixListReference
  where
  type
    AWSResponse
      CreateTransitGatewayPrefixListReference =
      CreateTransitGatewayPrefixListReferenceResponse
  request :: (Service -> Service)
-> CreateTransitGatewayPrefixListReference
-> Request CreateTransitGatewayPrefixListReference
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 CreateTransitGatewayPrefixListReference
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse
           (AWSResponse CreateTransitGatewayPrefixListReference)))
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 TransitGatewayPrefixListReference
-> Int -> CreateTransitGatewayPrefixListReferenceResponse
CreateTransitGatewayPrefixListReferenceResponse'
            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
"transitGatewayPrefixListReference")
            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
    CreateTransitGatewayPrefixListReference
  where
  hashWithSalt :: Int -> CreateTransitGatewayPrefixListReference -> Int
hashWithSalt
    Int
_salt
    CreateTransitGatewayPrefixListReference' {Maybe Bool
Maybe Text
Text
prefixListId :: Text
transitGatewayRouteTableId :: Text
transitGatewayAttachmentId :: Maybe Text
dryRun :: Maybe Bool
blackhole :: Maybe Bool
$sel:prefixListId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
$sel:transitGatewayRouteTableId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Text
$sel:dryRun:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
$sel:blackhole:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
blackhole
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
transitGatewayAttachmentId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
transitGatewayRouteTableId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
prefixListId

instance
  Prelude.NFData
    CreateTransitGatewayPrefixListReference
  where
  rnf :: CreateTransitGatewayPrefixListReference -> ()
rnf CreateTransitGatewayPrefixListReference' {Maybe Bool
Maybe Text
Text
prefixListId :: Text
transitGatewayRouteTableId :: Text
transitGatewayAttachmentId :: Maybe Text
dryRun :: Maybe Bool
blackhole :: Maybe Bool
$sel:prefixListId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
$sel:transitGatewayRouteTableId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Text
$sel:dryRun:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
$sel:blackhole:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
blackhole
      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 Text
transitGatewayAttachmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
transitGatewayRouteTableId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
prefixListId

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

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

instance
  Data.ToQuery
    CreateTransitGatewayPrefixListReference
  where
  toQuery :: CreateTransitGatewayPrefixListReference -> QueryString
toQuery CreateTransitGatewayPrefixListReference' {Maybe Bool
Maybe Text
Text
prefixListId :: Text
transitGatewayRouteTableId :: Text
transitGatewayAttachmentId :: Maybe Text
dryRun :: Maybe Bool
blackhole :: Maybe Bool
$sel:prefixListId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
$sel:transitGatewayRouteTableId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Text
$sel:transitGatewayAttachmentId:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Text
$sel:dryRun:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
$sel:blackhole:CreateTransitGatewayPrefixListReference' :: CreateTransitGatewayPrefixListReference -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"CreateTransitGatewayPrefixListReference" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"Blackhole" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
blackhole,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"TransitGatewayAttachmentId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
transitGatewayAttachmentId,
        ByteString
"TransitGatewayRouteTableId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
transitGatewayRouteTableId,
        ByteString
"PrefixListId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
prefixListId
      ]

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

-- |
-- Create a value of 'CreateTransitGatewayPrefixListReferenceResponse' 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:
--
-- 'transitGatewayPrefixListReference', 'createTransitGatewayPrefixListReferenceResponse_transitGatewayPrefixListReference' - Information about the prefix list reference.
--
-- 'httpStatus', 'createTransitGatewayPrefixListReferenceResponse_httpStatus' - The response's http status code.
newCreateTransitGatewayPrefixListReferenceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateTransitGatewayPrefixListReferenceResponse
newCreateTransitGatewayPrefixListReferenceResponse :: Int -> CreateTransitGatewayPrefixListReferenceResponse
newCreateTransitGatewayPrefixListReferenceResponse
  Int
pHttpStatus_ =
    CreateTransitGatewayPrefixListReferenceResponse'
      { $sel:transitGatewayPrefixListReference:CreateTransitGatewayPrefixListReferenceResponse' :: Maybe TransitGatewayPrefixListReference
transitGatewayPrefixListReference =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateTransitGatewayPrefixListReferenceResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Information about the prefix list reference.
createTransitGatewayPrefixListReferenceResponse_transitGatewayPrefixListReference :: Lens.Lens' CreateTransitGatewayPrefixListReferenceResponse (Prelude.Maybe TransitGatewayPrefixListReference)
createTransitGatewayPrefixListReferenceResponse_transitGatewayPrefixListReference :: Lens'
  CreateTransitGatewayPrefixListReferenceResponse
  (Maybe TransitGatewayPrefixListReference)
createTransitGatewayPrefixListReferenceResponse_transitGatewayPrefixListReference = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTransitGatewayPrefixListReferenceResponse' {Maybe TransitGatewayPrefixListReference
transitGatewayPrefixListReference :: Maybe TransitGatewayPrefixListReference
$sel:transitGatewayPrefixListReference:CreateTransitGatewayPrefixListReferenceResponse' :: CreateTransitGatewayPrefixListReferenceResponse
-> Maybe TransitGatewayPrefixListReference
transitGatewayPrefixListReference} -> Maybe TransitGatewayPrefixListReference
transitGatewayPrefixListReference) (\s :: CreateTransitGatewayPrefixListReferenceResponse
s@CreateTransitGatewayPrefixListReferenceResponse' {} Maybe TransitGatewayPrefixListReference
a -> CreateTransitGatewayPrefixListReferenceResponse
s {$sel:transitGatewayPrefixListReference:CreateTransitGatewayPrefixListReferenceResponse' :: Maybe TransitGatewayPrefixListReference
transitGatewayPrefixListReference = Maybe TransitGatewayPrefixListReference
a} :: CreateTransitGatewayPrefixListReferenceResponse)

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

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