{-# 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.ModifyTransitGateway
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Modifies the specified transit gateway. When you modify a transit
-- gateway, the modified options are applied to new transit gateway
-- attachments only. Your existing transit gateway attachments are not
-- modified.
module Amazonka.EC2.ModifyTransitGateway
  ( -- * Creating a Request
    ModifyTransitGateway (..),
    newModifyTransitGateway,

    -- * Request Lenses
    modifyTransitGateway_description,
    modifyTransitGateway_dryRun,
    modifyTransitGateway_options,
    modifyTransitGateway_transitGatewayId,

    -- * Destructuring the Response
    ModifyTransitGatewayResponse (..),
    newModifyTransitGatewayResponse,

    -- * Response Lenses
    modifyTransitGatewayResponse_transitGateway,
    modifyTransitGatewayResponse_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:/ 'newModifyTransitGateway' smart constructor.
data ModifyTransitGateway = ModifyTransitGateway'
  { -- | The description for the transit gateway.
    ModifyTransitGateway -> Maybe Text
description :: 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@.
    ModifyTransitGateway -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The options to modify.
    ModifyTransitGateway -> Maybe ModifyTransitGatewayOptions
options :: Prelude.Maybe ModifyTransitGatewayOptions,
    -- | The ID of the transit gateway.
    ModifyTransitGateway -> Text
transitGatewayId :: Prelude.Text
  }
  deriving (ModifyTransitGateway -> ModifyTransitGateway -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifyTransitGateway -> ModifyTransitGateway -> Bool
$c/= :: ModifyTransitGateway -> ModifyTransitGateway -> Bool
== :: ModifyTransitGateway -> ModifyTransitGateway -> Bool
$c== :: ModifyTransitGateway -> ModifyTransitGateway -> Bool
Prelude.Eq, ReadPrec [ModifyTransitGateway]
ReadPrec ModifyTransitGateway
Int -> ReadS ModifyTransitGateway
ReadS [ModifyTransitGateway]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModifyTransitGateway]
$creadListPrec :: ReadPrec [ModifyTransitGateway]
readPrec :: ReadPrec ModifyTransitGateway
$creadPrec :: ReadPrec ModifyTransitGateway
readList :: ReadS [ModifyTransitGateway]
$creadList :: ReadS [ModifyTransitGateway]
readsPrec :: Int -> ReadS ModifyTransitGateway
$creadsPrec :: Int -> ReadS ModifyTransitGateway
Prelude.Read, Int -> ModifyTransitGateway -> ShowS
[ModifyTransitGateway] -> ShowS
ModifyTransitGateway -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifyTransitGateway] -> ShowS
$cshowList :: [ModifyTransitGateway] -> ShowS
show :: ModifyTransitGateway -> String
$cshow :: ModifyTransitGateway -> String
showsPrec :: Int -> ModifyTransitGateway -> ShowS
$cshowsPrec :: Int -> ModifyTransitGateway -> ShowS
Prelude.Show, forall x. Rep ModifyTransitGateway x -> ModifyTransitGateway
forall x. ModifyTransitGateway -> Rep ModifyTransitGateway x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModifyTransitGateway x -> ModifyTransitGateway
$cfrom :: forall x. ModifyTransitGateway -> Rep ModifyTransitGateway x
Prelude.Generic)

-- |
-- Create a value of 'ModifyTransitGateway' 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:
--
-- 'description', 'modifyTransitGateway_description' - The description for the transit gateway.
--
-- 'dryRun', 'modifyTransitGateway_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@.
--
-- 'options', 'modifyTransitGateway_options' - The options to modify.
--
-- 'transitGatewayId', 'modifyTransitGateway_transitGatewayId' - The ID of the transit gateway.
newModifyTransitGateway ::
  -- | 'transitGatewayId'
  Prelude.Text ->
  ModifyTransitGateway
newModifyTransitGateway :: Text -> ModifyTransitGateway
newModifyTransitGateway Text
pTransitGatewayId_ =
  ModifyTransitGateway'
    { $sel:description:ModifyTransitGateway' :: Maybe Text
description =
        forall a. Maybe a
Prelude.Nothing,
      $sel:dryRun:ModifyTransitGateway' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:options:ModifyTransitGateway' :: Maybe ModifyTransitGatewayOptions
options = forall a. Maybe a
Prelude.Nothing,
      $sel:transitGatewayId:ModifyTransitGateway' :: Text
transitGatewayId = Text
pTransitGatewayId_
    }

-- | The description for the transit gateway.
modifyTransitGateway_description :: Lens.Lens' ModifyTransitGateway (Prelude.Maybe Prelude.Text)
modifyTransitGateway_description :: Lens' ModifyTransitGateway (Maybe Text)
modifyTransitGateway_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyTransitGateway' {Maybe Text
description :: Maybe Text
$sel:description:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Text
description} -> Maybe Text
description) (\s :: ModifyTransitGateway
s@ModifyTransitGateway' {} Maybe Text
a -> ModifyTransitGateway
s {$sel:description:ModifyTransitGateway' :: Maybe Text
description = Maybe Text
a} :: ModifyTransitGateway)

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

-- | The options to modify.
modifyTransitGateway_options :: Lens.Lens' ModifyTransitGateway (Prelude.Maybe ModifyTransitGatewayOptions)
modifyTransitGateway_options :: Lens' ModifyTransitGateway (Maybe ModifyTransitGatewayOptions)
modifyTransitGateway_options = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyTransitGateway' {Maybe ModifyTransitGatewayOptions
options :: Maybe ModifyTransitGatewayOptions
$sel:options:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe ModifyTransitGatewayOptions
options} -> Maybe ModifyTransitGatewayOptions
options) (\s :: ModifyTransitGateway
s@ModifyTransitGateway' {} Maybe ModifyTransitGatewayOptions
a -> ModifyTransitGateway
s {$sel:options:ModifyTransitGateway' :: Maybe ModifyTransitGatewayOptions
options = Maybe ModifyTransitGatewayOptions
a} :: ModifyTransitGateway)

-- | The ID of the transit gateway.
modifyTransitGateway_transitGatewayId :: Lens.Lens' ModifyTransitGateway Prelude.Text
modifyTransitGateway_transitGatewayId :: Lens' ModifyTransitGateway Text
modifyTransitGateway_transitGatewayId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyTransitGateway' {Text
transitGatewayId :: Text
$sel:transitGatewayId:ModifyTransitGateway' :: ModifyTransitGateway -> Text
transitGatewayId} -> Text
transitGatewayId) (\s :: ModifyTransitGateway
s@ModifyTransitGateway' {} Text
a -> ModifyTransitGateway
s {$sel:transitGatewayId:ModifyTransitGateway' :: Text
transitGatewayId = Text
a} :: ModifyTransitGateway)

instance Core.AWSRequest ModifyTransitGateway where
  type
    AWSResponse ModifyTransitGateway =
      ModifyTransitGatewayResponse
  request :: (Service -> Service)
-> ModifyTransitGateway -> Request ModifyTransitGateway
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 ModifyTransitGateway
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ModifyTransitGateway)))
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 TransitGateway -> Int -> ModifyTransitGatewayResponse
ModifyTransitGatewayResponse'
            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
"transitGateway")
            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 ModifyTransitGateway where
  hashWithSalt :: Int -> ModifyTransitGateway -> Int
hashWithSalt Int
_salt ModifyTransitGateway' {Maybe Bool
Maybe Text
Maybe ModifyTransitGatewayOptions
Text
transitGatewayId :: Text
options :: Maybe ModifyTransitGatewayOptions
dryRun :: Maybe Bool
description :: Maybe Text
$sel:transitGatewayId:ModifyTransitGateway' :: ModifyTransitGateway -> Text
$sel:options:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe ModifyTransitGatewayOptions
$sel:dryRun:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Bool
$sel:description:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ModifyTransitGatewayOptions
options
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
transitGatewayId

instance Prelude.NFData ModifyTransitGateway where
  rnf :: ModifyTransitGateway -> ()
rnf ModifyTransitGateway' {Maybe Bool
Maybe Text
Maybe ModifyTransitGatewayOptions
Text
transitGatewayId :: Text
options :: Maybe ModifyTransitGatewayOptions
dryRun :: Maybe Bool
description :: Maybe Text
$sel:transitGatewayId:ModifyTransitGateway' :: ModifyTransitGateway -> Text
$sel:options:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe ModifyTransitGatewayOptions
$sel:dryRun:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Bool
$sel:description:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      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 ModifyTransitGatewayOptions
options
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
transitGatewayId

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

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

instance Data.ToQuery ModifyTransitGateway where
  toQuery :: ModifyTransitGateway -> QueryString
toQuery ModifyTransitGateway' {Maybe Bool
Maybe Text
Maybe ModifyTransitGatewayOptions
Text
transitGatewayId :: Text
options :: Maybe ModifyTransitGatewayOptions
dryRun :: Maybe Bool
description :: Maybe Text
$sel:transitGatewayId:ModifyTransitGateway' :: ModifyTransitGateway -> Text
$sel:options:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe ModifyTransitGatewayOptions
$sel:dryRun:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Bool
$sel:description:ModifyTransitGateway' :: ModifyTransitGateway -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ModifyTransitGateway" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"Description" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
description,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"Options" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe ModifyTransitGatewayOptions
options,
        ByteString
"TransitGatewayId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
transitGatewayId
      ]

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

-- |
-- Create a value of 'ModifyTransitGatewayResponse' 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:
--
-- 'transitGateway', 'modifyTransitGatewayResponse_transitGateway' - Information about the transit gateway.
--
-- 'httpStatus', 'modifyTransitGatewayResponse_httpStatus' - The response's http status code.
newModifyTransitGatewayResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ModifyTransitGatewayResponse
newModifyTransitGatewayResponse :: Int -> ModifyTransitGatewayResponse
newModifyTransitGatewayResponse Int
pHttpStatus_ =
  ModifyTransitGatewayResponse'
    { $sel:transitGateway:ModifyTransitGatewayResponse' :: Maybe TransitGateway
transitGateway =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ModifyTransitGatewayResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the transit gateway.
modifyTransitGatewayResponse_transitGateway :: Lens.Lens' ModifyTransitGatewayResponse (Prelude.Maybe TransitGateway)
modifyTransitGatewayResponse_transitGateway :: Lens' ModifyTransitGatewayResponse (Maybe TransitGateway)
modifyTransitGatewayResponse_transitGateway = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyTransitGatewayResponse' {Maybe TransitGateway
transitGateway :: Maybe TransitGateway
$sel:transitGateway:ModifyTransitGatewayResponse' :: ModifyTransitGatewayResponse -> Maybe TransitGateway
transitGateway} -> Maybe TransitGateway
transitGateway) (\s :: ModifyTransitGatewayResponse
s@ModifyTransitGatewayResponse' {} Maybe TransitGateway
a -> ModifyTransitGatewayResponse
s {$sel:transitGateway:ModifyTransitGatewayResponse' :: Maybe TransitGateway
transitGateway = Maybe TransitGateway
a} :: ModifyTransitGatewayResponse)

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

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