{-# 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.DeleteTransitGatewayRouteTable
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the specified transit gateway route table. You must disassociate
-- the route table from any transit gateway route tables before you can
-- delete it.
module Amazonka.EC2.DeleteTransitGatewayRouteTable
  ( -- * Creating a Request
    DeleteTransitGatewayRouteTable (..),
    newDeleteTransitGatewayRouteTable,

    -- * Request Lenses
    deleteTransitGatewayRouteTable_dryRun,
    deleteTransitGatewayRouteTable_transitGatewayRouteTableId,

    -- * Destructuring the Response
    DeleteTransitGatewayRouteTableResponse (..),
    newDeleteTransitGatewayRouteTableResponse,

    -- * Response Lenses
    deleteTransitGatewayRouteTableResponse_transitGatewayRouteTable,
    deleteTransitGatewayRouteTableResponse_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:/ 'newDeleteTransitGatewayRouteTable' smart constructor.
data DeleteTransitGatewayRouteTable = DeleteTransitGatewayRouteTable'
  { -- | 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@.
    DeleteTransitGatewayRouteTable -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the transit gateway route table.
    DeleteTransitGatewayRouteTable -> Text
transitGatewayRouteTableId :: Prelude.Text
  }
  deriving (DeleteTransitGatewayRouteTable
-> DeleteTransitGatewayRouteTable -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTransitGatewayRouteTable
-> DeleteTransitGatewayRouteTable -> Bool
$c/= :: DeleteTransitGatewayRouteTable
-> DeleteTransitGatewayRouteTable -> Bool
== :: DeleteTransitGatewayRouteTable
-> DeleteTransitGatewayRouteTable -> Bool
$c== :: DeleteTransitGatewayRouteTable
-> DeleteTransitGatewayRouteTable -> Bool
Prelude.Eq, ReadPrec [DeleteTransitGatewayRouteTable]
ReadPrec DeleteTransitGatewayRouteTable
Int -> ReadS DeleteTransitGatewayRouteTable
ReadS [DeleteTransitGatewayRouteTable]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTransitGatewayRouteTable]
$creadListPrec :: ReadPrec [DeleteTransitGatewayRouteTable]
readPrec :: ReadPrec DeleteTransitGatewayRouteTable
$creadPrec :: ReadPrec DeleteTransitGatewayRouteTable
readList :: ReadS [DeleteTransitGatewayRouteTable]
$creadList :: ReadS [DeleteTransitGatewayRouteTable]
readsPrec :: Int -> ReadS DeleteTransitGatewayRouteTable
$creadsPrec :: Int -> ReadS DeleteTransitGatewayRouteTable
Prelude.Read, Int -> DeleteTransitGatewayRouteTable -> ShowS
[DeleteTransitGatewayRouteTable] -> ShowS
DeleteTransitGatewayRouteTable -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTransitGatewayRouteTable] -> ShowS
$cshowList :: [DeleteTransitGatewayRouteTable] -> ShowS
show :: DeleteTransitGatewayRouteTable -> String
$cshow :: DeleteTransitGatewayRouteTable -> String
showsPrec :: Int -> DeleteTransitGatewayRouteTable -> ShowS
$cshowsPrec :: Int -> DeleteTransitGatewayRouteTable -> ShowS
Prelude.Show, forall x.
Rep DeleteTransitGatewayRouteTable x
-> DeleteTransitGatewayRouteTable
forall x.
DeleteTransitGatewayRouteTable
-> Rep DeleteTransitGatewayRouteTable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteTransitGatewayRouteTable x
-> DeleteTransitGatewayRouteTable
$cfrom :: forall x.
DeleteTransitGatewayRouteTable
-> Rep DeleteTransitGatewayRouteTable x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTransitGatewayRouteTable' 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', 'deleteTransitGatewayRouteTable_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@.
--
-- 'transitGatewayRouteTableId', 'deleteTransitGatewayRouteTable_transitGatewayRouteTableId' - The ID of the transit gateway route table.
newDeleteTransitGatewayRouteTable ::
  -- | 'transitGatewayRouteTableId'
  Prelude.Text ->
  DeleteTransitGatewayRouteTable
newDeleteTransitGatewayRouteTable :: Text -> DeleteTransitGatewayRouteTable
newDeleteTransitGatewayRouteTable
  Text
pTransitGatewayRouteTableId_ =
    DeleteTransitGatewayRouteTable'
      { $sel:dryRun:DeleteTransitGatewayRouteTable' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayRouteTableId:DeleteTransitGatewayRouteTable' :: Text
transitGatewayRouteTableId =
          Text
pTransitGatewayRouteTableId_
      }

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

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

instance
  Core.AWSRequest
    DeleteTransitGatewayRouteTable
  where
  type
    AWSResponse DeleteTransitGatewayRouteTable =
      DeleteTransitGatewayRouteTableResponse
  request :: (Service -> Service)
-> DeleteTransitGatewayRouteTable
-> Request DeleteTransitGatewayRouteTable
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 DeleteTransitGatewayRouteTable
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse DeleteTransitGatewayRouteTable)))
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 TransitGatewayRouteTable
-> Int -> DeleteTransitGatewayRouteTableResponse
DeleteTransitGatewayRouteTableResponse'
            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
"transitGatewayRouteTable")
            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
    DeleteTransitGatewayRouteTable
  where
  hashWithSalt :: Int -> DeleteTransitGatewayRouteTable -> Int
hashWithSalt
    Int
_salt
    DeleteTransitGatewayRouteTable' {Maybe Bool
Text
transitGatewayRouteTableId :: Text
dryRun :: Maybe Bool
$sel:transitGatewayRouteTableId:DeleteTransitGatewayRouteTable' :: DeleteTransitGatewayRouteTable -> Text
$sel:dryRun:DeleteTransitGatewayRouteTable' :: DeleteTransitGatewayRouteTable -> 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` Text
transitGatewayRouteTableId

instance
  Prelude.NFData
    DeleteTransitGatewayRouteTable
  where
  rnf :: DeleteTransitGatewayRouteTable -> ()
rnf DeleteTransitGatewayRouteTable' {Maybe Bool
Text
transitGatewayRouteTableId :: Text
dryRun :: Maybe Bool
$sel:transitGatewayRouteTableId:DeleteTransitGatewayRouteTable' :: DeleteTransitGatewayRouteTable -> Text
$sel:dryRun:DeleteTransitGatewayRouteTable' :: DeleteTransitGatewayRouteTable -> 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 Text
transitGatewayRouteTableId

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

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

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

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

-- |
-- Create a value of 'DeleteTransitGatewayRouteTableResponse' 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:
--
-- 'transitGatewayRouteTable', 'deleteTransitGatewayRouteTableResponse_transitGatewayRouteTable' - Information about the deleted transit gateway route table.
--
-- 'httpStatus', 'deleteTransitGatewayRouteTableResponse_httpStatus' - The response's http status code.
newDeleteTransitGatewayRouteTableResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteTransitGatewayRouteTableResponse
newDeleteTransitGatewayRouteTableResponse :: Int -> DeleteTransitGatewayRouteTableResponse
newDeleteTransitGatewayRouteTableResponse
  Int
pHttpStatus_ =
    DeleteTransitGatewayRouteTableResponse'
      { $sel:transitGatewayRouteTable:DeleteTransitGatewayRouteTableResponse' :: Maybe TransitGatewayRouteTable
transitGatewayRouteTable =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:DeleteTransitGatewayRouteTableResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Information about the deleted transit gateway route table.
deleteTransitGatewayRouteTableResponse_transitGatewayRouteTable :: Lens.Lens' DeleteTransitGatewayRouteTableResponse (Prelude.Maybe TransitGatewayRouteTable)
deleteTransitGatewayRouteTableResponse_transitGatewayRouteTable :: Lens'
  DeleteTransitGatewayRouteTableResponse
  (Maybe TransitGatewayRouteTable)
deleteTransitGatewayRouteTableResponse_transitGatewayRouteTable = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTransitGatewayRouteTableResponse' {Maybe TransitGatewayRouteTable
transitGatewayRouteTable :: Maybe TransitGatewayRouteTable
$sel:transitGatewayRouteTable:DeleteTransitGatewayRouteTableResponse' :: DeleteTransitGatewayRouteTableResponse
-> Maybe TransitGatewayRouteTable
transitGatewayRouteTable} -> Maybe TransitGatewayRouteTable
transitGatewayRouteTable) (\s :: DeleteTransitGatewayRouteTableResponse
s@DeleteTransitGatewayRouteTableResponse' {} Maybe TransitGatewayRouteTable
a -> DeleteTransitGatewayRouteTableResponse
s {$sel:transitGatewayRouteTable:DeleteTransitGatewayRouteTableResponse' :: Maybe TransitGatewayRouteTable
transitGatewayRouteTable = Maybe TransitGatewayRouteTable
a} :: DeleteTransitGatewayRouteTableResponse)

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

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