{-# 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.ReplaceTransitGatewayRoute
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Replaces the specified route in the specified transit gateway route
-- table.
module Amazonka.EC2.ReplaceTransitGatewayRoute
  ( -- * Creating a Request
    ReplaceTransitGatewayRoute (..),
    newReplaceTransitGatewayRoute,

    -- * Request Lenses
    replaceTransitGatewayRoute_blackhole,
    replaceTransitGatewayRoute_dryRun,
    replaceTransitGatewayRoute_transitGatewayAttachmentId,
    replaceTransitGatewayRoute_destinationCidrBlock,
    replaceTransitGatewayRoute_transitGatewayRouteTableId,

    -- * Destructuring the Response
    ReplaceTransitGatewayRouteResponse (..),
    newReplaceTransitGatewayRouteResponse,

    -- * Response Lenses
    replaceTransitGatewayRouteResponse_route,
    replaceTransitGatewayRouteResponse_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:/ 'newReplaceTransitGatewayRoute' smart constructor.
data ReplaceTransitGatewayRoute = ReplaceTransitGatewayRoute'
  { -- | Indicates whether traffic matching this route is to be dropped.
    ReplaceTransitGatewayRoute -> 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@.
    ReplaceTransitGatewayRoute -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the attachment.
    ReplaceTransitGatewayRoute -> Maybe Text
transitGatewayAttachmentId :: Prelude.Maybe Prelude.Text,
    -- | The CIDR range used for the destination match. Routing decisions are
    -- based on the most specific match.
    ReplaceTransitGatewayRoute -> Text
destinationCidrBlock :: Prelude.Text,
    -- | The ID of the route table.
    ReplaceTransitGatewayRoute -> Text
transitGatewayRouteTableId :: Prelude.Text
  }
  deriving (ReplaceTransitGatewayRoute -> ReplaceTransitGatewayRoute -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReplaceTransitGatewayRoute -> ReplaceTransitGatewayRoute -> Bool
$c/= :: ReplaceTransitGatewayRoute -> ReplaceTransitGatewayRoute -> Bool
== :: ReplaceTransitGatewayRoute -> ReplaceTransitGatewayRoute -> Bool
$c== :: ReplaceTransitGatewayRoute -> ReplaceTransitGatewayRoute -> Bool
Prelude.Eq, ReadPrec [ReplaceTransitGatewayRoute]
ReadPrec ReplaceTransitGatewayRoute
Int -> ReadS ReplaceTransitGatewayRoute
ReadS [ReplaceTransitGatewayRoute]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ReplaceTransitGatewayRoute]
$creadListPrec :: ReadPrec [ReplaceTransitGatewayRoute]
readPrec :: ReadPrec ReplaceTransitGatewayRoute
$creadPrec :: ReadPrec ReplaceTransitGatewayRoute
readList :: ReadS [ReplaceTransitGatewayRoute]
$creadList :: ReadS [ReplaceTransitGatewayRoute]
readsPrec :: Int -> ReadS ReplaceTransitGatewayRoute
$creadsPrec :: Int -> ReadS ReplaceTransitGatewayRoute
Prelude.Read, Int -> ReplaceTransitGatewayRoute -> ShowS
[ReplaceTransitGatewayRoute] -> ShowS
ReplaceTransitGatewayRoute -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReplaceTransitGatewayRoute] -> ShowS
$cshowList :: [ReplaceTransitGatewayRoute] -> ShowS
show :: ReplaceTransitGatewayRoute -> String
$cshow :: ReplaceTransitGatewayRoute -> String
showsPrec :: Int -> ReplaceTransitGatewayRoute -> ShowS
$cshowsPrec :: Int -> ReplaceTransitGatewayRoute -> ShowS
Prelude.Show, forall x.
Rep ReplaceTransitGatewayRoute x -> ReplaceTransitGatewayRoute
forall x.
ReplaceTransitGatewayRoute -> Rep ReplaceTransitGatewayRoute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ReplaceTransitGatewayRoute x -> ReplaceTransitGatewayRoute
$cfrom :: forall x.
ReplaceTransitGatewayRoute -> Rep ReplaceTransitGatewayRoute x
Prelude.Generic)

-- |
-- Create a value of 'ReplaceTransitGatewayRoute' 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', 'replaceTransitGatewayRoute_blackhole' - Indicates whether traffic matching this route is to be dropped.
--
-- 'dryRun', 'replaceTransitGatewayRoute_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', 'replaceTransitGatewayRoute_transitGatewayAttachmentId' - The ID of the attachment.
--
-- 'destinationCidrBlock', 'replaceTransitGatewayRoute_destinationCidrBlock' - The CIDR range used for the destination match. Routing decisions are
-- based on the most specific match.
--
-- 'transitGatewayRouteTableId', 'replaceTransitGatewayRoute_transitGatewayRouteTableId' - The ID of the route table.
newReplaceTransitGatewayRoute ::
  -- | 'destinationCidrBlock'
  Prelude.Text ->
  -- | 'transitGatewayRouteTableId'
  Prelude.Text ->
  ReplaceTransitGatewayRoute
newReplaceTransitGatewayRoute :: Text -> Text -> ReplaceTransitGatewayRoute
newReplaceTransitGatewayRoute
  Text
pDestinationCidrBlock_
  Text
pTransitGatewayRouteTableId_ =
    ReplaceTransitGatewayRoute'
      { $sel:blackhole:ReplaceTransitGatewayRoute' :: Maybe Bool
blackhole =
          forall a. Maybe a
Prelude.Nothing,
        $sel:dryRun:ReplaceTransitGatewayRoute' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayAttachmentId:ReplaceTransitGatewayRoute' :: Maybe Text
transitGatewayAttachmentId = forall a. Maybe a
Prelude.Nothing,
        $sel:destinationCidrBlock:ReplaceTransitGatewayRoute' :: Text
destinationCidrBlock = Text
pDestinationCidrBlock_,
        $sel:transitGatewayRouteTableId:ReplaceTransitGatewayRoute' :: Text
transitGatewayRouteTableId =
          Text
pTransitGatewayRouteTableId_
      }

-- | Indicates whether traffic matching this route is to be dropped.
replaceTransitGatewayRoute_blackhole :: Lens.Lens' ReplaceTransitGatewayRoute (Prelude.Maybe Prelude.Bool)
replaceTransitGatewayRoute_blackhole :: Lens' ReplaceTransitGatewayRoute (Maybe Bool)
replaceTransitGatewayRoute_blackhole = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReplaceTransitGatewayRoute' {Maybe Bool
blackhole :: Maybe Bool
$sel:blackhole:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Maybe Bool
blackhole} -> Maybe Bool
blackhole) (\s :: ReplaceTransitGatewayRoute
s@ReplaceTransitGatewayRoute' {} Maybe Bool
a -> ReplaceTransitGatewayRoute
s {$sel:blackhole:ReplaceTransitGatewayRoute' :: Maybe Bool
blackhole = Maybe Bool
a} :: ReplaceTransitGatewayRoute)

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

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

-- | The CIDR range used for the destination match. Routing decisions are
-- based on the most specific match.
replaceTransitGatewayRoute_destinationCidrBlock :: Lens.Lens' ReplaceTransitGatewayRoute Prelude.Text
replaceTransitGatewayRoute_destinationCidrBlock :: Lens' ReplaceTransitGatewayRoute Text
replaceTransitGatewayRoute_destinationCidrBlock = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReplaceTransitGatewayRoute' {Text
destinationCidrBlock :: Text
$sel:destinationCidrBlock:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Text
destinationCidrBlock} -> Text
destinationCidrBlock) (\s :: ReplaceTransitGatewayRoute
s@ReplaceTransitGatewayRoute' {} Text
a -> ReplaceTransitGatewayRoute
s {$sel:destinationCidrBlock:ReplaceTransitGatewayRoute' :: Text
destinationCidrBlock = Text
a} :: ReplaceTransitGatewayRoute)

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

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

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

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

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

instance Data.ToQuery ReplaceTransitGatewayRoute where
  toQuery :: ReplaceTransitGatewayRoute -> QueryString
toQuery ReplaceTransitGatewayRoute' {Maybe Bool
Maybe Text
Text
transitGatewayRouteTableId :: Text
destinationCidrBlock :: Text
transitGatewayAttachmentId :: Maybe Text
dryRun :: Maybe Bool
blackhole :: Maybe Bool
$sel:transitGatewayRouteTableId:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Text
$sel:destinationCidrBlock:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Text
$sel:transitGatewayAttachmentId:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Maybe Text
$sel:dryRun:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Maybe Bool
$sel:blackhole:ReplaceTransitGatewayRoute' :: ReplaceTransitGatewayRoute -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ReplaceTransitGatewayRoute" :: 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
"DestinationCidrBlock" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
destinationCidrBlock,
        ByteString
"TransitGatewayRouteTableId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
transitGatewayRouteTableId
      ]

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

-- |
-- Create a value of 'ReplaceTransitGatewayRouteResponse' 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:
--
-- 'route', 'replaceTransitGatewayRouteResponse_route' - Information about the modified route.
--
-- 'httpStatus', 'replaceTransitGatewayRouteResponse_httpStatus' - The response's http status code.
newReplaceTransitGatewayRouteResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ReplaceTransitGatewayRouteResponse
newReplaceTransitGatewayRouteResponse :: Int -> ReplaceTransitGatewayRouteResponse
newReplaceTransitGatewayRouteResponse Int
pHttpStatus_ =
  ReplaceTransitGatewayRouteResponse'
    { $sel:route:ReplaceTransitGatewayRouteResponse' :: Maybe TransitGatewayRoute
route =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ReplaceTransitGatewayRouteResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the modified route.
replaceTransitGatewayRouteResponse_route :: Lens.Lens' ReplaceTransitGatewayRouteResponse (Prelude.Maybe TransitGatewayRoute)
replaceTransitGatewayRouteResponse_route :: Lens'
  ReplaceTransitGatewayRouteResponse (Maybe TransitGatewayRoute)
replaceTransitGatewayRouteResponse_route = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReplaceTransitGatewayRouteResponse' {Maybe TransitGatewayRoute
route :: Maybe TransitGatewayRoute
$sel:route:ReplaceTransitGatewayRouteResponse' :: ReplaceTransitGatewayRouteResponse -> Maybe TransitGatewayRoute
route} -> Maybe TransitGatewayRoute
route) (\s :: ReplaceTransitGatewayRouteResponse
s@ReplaceTransitGatewayRouteResponse' {} Maybe TransitGatewayRoute
a -> ReplaceTransitGatewayRouteResponse
s {$sel:route:ReplaceTransitGatewayRouteResponse' :: Maybe TransitGatewayRoute
route = Maybe TransitGatewayRoute
a} :: ReplaceTransitGatewayRouteResponse)

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

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