{-# 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.DeleteTransitGatewayConnect
-- 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 Connect attachment. You must first delete any
-- Connect peers for the attachment.
module Amazonka.EC2.DeleteTransitGatewayConnect
  ( -- * Creating a Request
    DeleteTransitGatewayConnect (..),
    newDeleteTransitGatewayConnect,

    -- * Request Lenses
    deleteTransitGatewayConnect_dryRun,
    deleteTransitGatewayConnect_transitGatewayAttachmentId,

    -- * Destructuring the Response
    DeleteTransitGatewayConnectResponse (..),
    newDeleteTransitGatewayConnectResponse,

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

-- |
-- Create a value of 'DeleteTransitGatewayConnect' 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', 'deleteTransitGatewayConnect_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', 'deleteTransitGatewayConnect_transitGatewayAttachmentId' - The ID of the Connect attachment.
newDeleteTransitGatewayConnect ::
  -- | 'transitGatewayAttachmentId'
  Prelude.Text ->
  DeleteTransitGatewayConnect
newDeleteTransitGatewayConnect :: Text -> DeleteTransitGatewayConnect
newDeleteTransitGatewayConnect
  Text
pTransitGatewayAttachmentId_ =
    DeleteTransitGatewayConnect'
      { $sel:dryRun:DeleteTransitGatewayConnect' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayAttachmentId:DeleteTransitGatewayConnect' :: Text
transitGatewayAttachmentId =
          Text
pTransitGatewayAttachmentId_
      }

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

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

instance Core.AWSRequest DeleteTransitGatewayConnect where
  type
    AWSResponse DeleteTransitGatewayConnect =
      DeleteTransitGatewayConnectResponse
  request :: (Service -> Service)
-> DeleteTransitGatewayConnect
-> Request DeleteTransitGatewayConnect
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 DeleteTransitGatewayConnect
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeleteTransitGatewayConnect)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe TransitGatewayConnect
-> Int -> DeleteTransitGatewayConnectResponse
DeleteTransitGatewayConnectResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"transitGatewayConnect")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable DeleteTransitGatewayConnect where
  hashWithSalt :: Int -> DeleteTransitGatewayConnect -> Int
hashWithSalt Int
_salt DeleteTransitGatewayConnect' {Maybe Bool
Text
transitGatewayAttachmentId :: Text
dryRun :: Maybe Bool
$sel:transitGatewayAttachmentId:DeleteTransitGatewayConnect' :: DeleteTransitGatewayConnect -> Text
$sel:dryRun:DeleteTransitGatewayConnect' :: DeleteTransitGatewayConnect -> 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
transitGatewayAttachmentId

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

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

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

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

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

-- |
-- Create a value of 'DeleteTransitGatewayConnectResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'transitGatewayConnect', 'deleteTransitGatewayConnectResponse_transitGatewayConnect' - Information about the deleted Connect attachment.
--
-- 'httpStatus', 'deleteTransitGatewayConnectResponse_httpStatus' - The response's http status code.
newDeleteTransitGatewayConnectResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteTransitGatewayConnectResponse
newDeleteTransitGatewayConnectResponse :: Int -> DeleteTransitGatewayConnectResponse
newDeleteTransitGatewayConnectResponse Int
pHttpStatus_ =
  DeleteTransitGatewayConnectResponse'
    { $sel:transitGatewayConnect:DeleteTransitGatewayConnectResponse' :: Maybe TransitGatewayConnect
transitGatewayConnect =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DeleteTransitGatewayConnectResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

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

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