{-# 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 #-}
module Amazonka.NetworkManager.RegisterTransitGateway
(
RegisterTransitGateway (..),
newRegisterTransitGateway,
registerTransitGateway_globalNetworkId,
registerTransitGateway_transitGatewayArn,
RegisterTransitGatewayResponse (..),
newRegisterTransitGatewayResponse,
registerTransitGatewayResponse_transitGatewayRegistration,
registerTransitGatewayResponse_httpStatus,
)
where
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.NetworkManager.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
data RegisterTransitGateway = RegisterTransitGateway'
{
RegisterTransitGateway -> Text
globalNetworkId :: Prelude.Text,
RegisterTransitGateway -> Text
transitGatewayArn :: Prelude.Text
}
deriving (RegisterTransitGateway -> RegisterTransitGateway -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterTransitGateway -> RegisterTransitGateway -> Bool
$c/= :: RegisterTransitGateway -> RegisterTransitGateway -> Bool
== :: RegisterTransitGateway -> RegisterTransitGateway -> Bool
$c== :: RegisterTransitGateway -> RegisterTransitGateway -> Bool
Prelude.Eq, ReadPrec [RegisterTransitGateway]
ReadPrec RegisterTransitGateway
Int -> ReadS RegisterTransitGateway
ReadS [RegisterTransitGateway]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterTransitGateway]
$creadListPrec :: ReadPrec [RegisterTransitGateway]
readPrec :: ReadPrec RegisterTransitGateway
$creadPrec :: ReadPrec RegisterTransitGateway
readList :: ReadS [RegisterTransitGateway]
$creadList :: ReadS [RegisterTransitGateway]
readsPrec :: Int -> ReadS RegisterTransitGateway
$creadsPrec :: Int -> ReadS RegisterTransitGateway
Prelude.Read, Int -> RegisterTransitGateway -> ShowS
[RegisterTransitGateway] -> ShowS
RegisterTransitGateway -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterTransitGateway] -> ShowS
$cshowList :: [RegisterTransitGateway] -> ShowS
show :: RegisterTransitGateway -> String
$cshow :: RegisterTransitGateway -> String
showsPrec :: Int -> RegisterTransitGateway -> ShowS
$cshowsPrec :: Int -> RegisterTransitGateway -> ShowS
Prelude.Show, forall x. Rep RegisterTransitGateway x -> RegisterTransitGateway
forall x. RegisterTransitGateway -> Rep RegisterTransitGateway x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegisterTransitGateway x -> RegisterTransitGateway
$cfrom :: forall x. RegisterTransitGateway -> Rep RegisterTransitGateway x
Prelude.Generic)
newRegisterTransitGateway ::
Prelude.Text ->
Prelude.Text ->
RegisterTransitGateway
newRegisterTransitGateway :: Text -> Text -> RegisterTransitGateway
newRegisterTransitGateway
Text
pGlobalNetworkId_
Text
pTransitGatewayArn_ =
RegisterTransitGateway'
{ $sel:globalNetworkId:RegisterTransitGateway' :: Text
globalNetworkId =
Text
pGlobalNetworkId_,
$sel:transitGatewayArn:RegisterTransitGateway' :: Text
transitGatewayArn = Text
pTransitGatewayArn_
}
registerTransitGateway_globalNetworkId :: Lens.Lens' RegisterTransitGateway Prelude.Text
registerTransitGateway_globalNetworkId :: Lens' RegisterTransitGateway Text
registerTransitGateway_globalNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterTransitGateway' {Text
globalNetworkId :: Text
$sel:globalNetworkId:RegisterTransitGateway' :: RegisterTransitGateway -> Text
globalNetworkId} -> Text
globalNetworkId) (\s :: RegisterTransitGateway
s@RegisterTransitGateway' {} Text
a -> RegisterTransitGateway
s {$sel:globalNetworkId:RegisterTransitGateway' :: Text
globalNetworkId = Text
a} :: RegisterTransitGateway)
registerTransitGateway_transitGatewayArn :: Lens.Lens' RegisterTransitGateway Prelude.Text
registerTransitGateway_transitGatewayArn :: Lens' RegisterTransitGateway Text
registerTransitGateway_transitGatewayArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterTransitGateway' {Text
transitGatewayArn :: Text
$sel:transitGatewayArn:RegisterTransitGateway' :: RegisterTransitGateway -> Text
transitGatewayArn} -> Text
transitGatewayArn) (\s :: RegisterTransitGateway
s@RegisterTransitGateway' {} Text
a -> RegisterTransitGateway
s {$sel:transitGatewayArn:RegisterTransitGateway' :: Text
transitGatewayArn = Text
a} :: RegisterTransitGateway)
instance Core.AWSRequest RegisterTransitGateway where
type
AWSResponse RegisterTransitGateway =
RegisterTransitGatewayResponse
request :: (Service -> Service)
-> RegisterTransitGateway -> Request RegisterTransitGateway
request Service -> Service
overrides =
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy RegisterTransitGateway
-> ClientResponse ClientBody
-> m (Either
Error (ClientResponse (AWSResponse RegisterTransitGateway)))
response =
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
( \Int
s ResponseHeaders
h Object
x ->
Maybe TransitGatewayRegistration
-> Int -> RegisterTransitGatewayResponse
RegisterTransitGatewayResponse'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"TransitGatewayRegistration")
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 RegisterTransitGateway where
hashWithSalt :: Int -> RegisterTransitGateway -> Int
hashWithSalt Int
_salt RegisterTransitGateway' {Text
transitGatewayArn :: Text
globalNetworkId :: Text
$sel:transitGatewayArn:RegisterTransitGateway' :: RegisterTransitGateway -> Text
$sel:globalNetworkId:RegisterTransitGateway' :: RegisterTransitGateway -> Text
..} =
Int
_salt
forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
globalNetworkId
forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
transitGatewayArn
instance Prelude.NFData RegisterTransitGateway where
rnf :: RegisterTransitGateway -> ()
rnf RegisterTransitGateway' {Text
transitGatewayArn :: Text
globalNetworkId :: Text
$sel:transitGatewayArn:RegisterTransitGateway' :: RegisterTransitGateway -> Text
$sel:globalNetworkId:RegisterTransitGateway' :: RegisterTransitGateway -> Text
..} =
forall a. NFData a => a -> ()
Prelude.rnf Text
globalNetworkId
seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
transitGatewayArn
instance Data.ToHeaders RegisterTransitGateway where
toHeaders :: RegisterTransitGateway -> ResponseHeaders
toHeaders =
forall a b. a -> b -> a
Prelude.const
( forall a. Monoid a => [a] -> a
Prelude.mconcat
[ HeaderName
"Content-Type"
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
Prelude.ByteString
)
]
)
instance Data.ToJSON RegisterTransitGateway where
toJSON :: RegisterTransitGateway -> Value
toJSON RegisterTransitGateway' {Text
transitGatewayArn :: Text
globalNetworkId :: Text
$sel:transitGatewayArn:RegisterTransitGateway' :: RegisterTransitGateway -> Text
$sel:globalNetworkId:RegisterTransitGateway' :: RegisterTransitGateway -> Text
..} =
[Pair] -> Value
Data.object
( forall a. [Maybe a] -> [a]
Prelude.catMaybes
[ forall a. a -> Maybe a
Prelude.Just
(Key
"TransitGatewayArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
transitGatewayArn)
]
)
instance Data.ToPath RegisterTransitGateway where
toPath :: RegisterTransitGateway -> ByteString
toPath RegisterTransitGateway' {Text
transitGatewayArn :: Text
globalNetworkId :: Text
$sel:transitGatewayArn:RegisterTransitGateway' :: RegisterTransitGateway -> Text
$sel:globalNetworkId:RegisterTransitGateway' :: RegisterTransitGateway -> Text
..} =
forall a. Monoid a => [a] -> a
Prelude.mconcat
[ ByteString
"/global-networks/",
forall a. ToByteString a => a -> ByteString
Data.toBS Text
globalNetworkId,
ByteString
"/transit-gateway-registrations"
]
instance Data.ToQuery RegisterTransitGateway where
toQuery :: RegisterTransitGateway -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty
data RegisterTransitGatewayResponse = RegisterTransitGatewayResponse'
{
RegisterTransitGatewayResponse -> Maybe TransitGatewayRegistration
transitGatewayRegistration :: Prelude.Maybe TransitGatewayRegistration,
RegisterTransitGatewayResponse -> Int
httpStatus :: Prelude.Int
}
deriving (RegisterTransitGatewayResponse
-> RegisterTransitGatewayResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterTransitGatewayResponse
-> RegisterTransitGatewayResponse -> Bool
$c/= :: RegisterTransitGatewayResponse
-> RegisterTransitGatewayResponse -> Bool
== :: RegisterTransitGatewayResponse
-> RegisterTransitGatewayResponse -> Bool
$c== :: RegisterTransitGatewayResponse
-> RegisterTransitGatewayResponse -> Bool
Prelude.Eq, ReadPrec [RegisterTransitGatewayResponse]
ReadPrec RegisterTransitGatewayResponse
Int -> ReadS RegisterTransitGatewayResponse
ReadS [RegisterTransitGatewayResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterTransitGatewayResponse]
$creadListPrec :: ReadPrec [RegisterTransitGatewayResponse]
readPrec :: ReadPrec RegisterTransitGatewayResponse
$creadPrec :: ReadPrec RegisterTransitGatewayResponse
readList :: ReadS [RegisterTransitGatewayResponse]
$creadList :: ReadS [RegisterTransitGatewayResponse]
readsPrec :: Int -> ReadS RegisterTransitGatewayResponse
$creadsPrec :: Int -> ReadS RegisterTransitGatewayResponse
Prelude.Read, Int -> RegisterTransitGatewayResponse -> ShowS
[RegisterTransitGatewayResponse] -> ShowS
RegisterTransitGatewayResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterTransitGatewayResponse] -> ShowS
$cshowList :: [RegisterTransitGatewayResponse] -> ShowS
show :: RegisterTransitGatewayResponse -> String
$cshow :: RegisterTransitGatewayResponse -> String
showsPrec :: Int -> RegisterTransitGatewayResponse -> ShowS
$cshowsPrec :: Int -> RegisterTransitGatewayResponse -> ShowS
Prelude.Show, forall x.
Rep RegisterTransitGatewayResponse x
-> RegisterTransitGatewayResponse
forall x.
RegisterTransitGatewayResponse
-> Rep RegisterTransitGatewayResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RegisterTransitGatewayResponse x
-> RegisterTransitGatewayResponse
$cfrom :: forall x.
RegisterTransitGatewayResponse
-> Rep RegisterTransitGatewayResponse x
Prelude.Generic)
newRegisterTransitGatewayResponse ::
Prelude.Int ->
RegisterTransitGatewayResponse
newRegisterTransitGatewayResponse :: Int -> RegisterTransitGatewayResponse
newRegisterTransitGatewayResponse Int
pHttpStatus_ =
RegisterTransitGatewayResponse'
{ $sel:transitGatewayRegistration:RegisterTransitGatewayResponse' :: Maybe TransitGatewayRegistration
transitGatewayRegistration =
forall a. Maybe a
Prelude.Nothing,
$sel:httpStatus:RegisterTransitGatewayResponse' :: Int
httpStatus = Int
pHttpStatus_
}
registerTransitGatewayResponse_transitGatewayRegistration :: Lens.Lens' RegisterTransitGatewayResponse (Prelude.Maybe TransitGatewayRegistration)
registerTransitGatewayResponse_transitGatewayRegistration :: Lens'
RegisterTransitGatewayResponse (Maybe TransitGatewayRegistration)
registerTransitGatewayResponse_transitGatewayRegistration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterTransitGatewayResponse' {Maybe TransitGatewayRegistration
transitGatewayRegistration :: Maybe TransitGatewayRegistration
$sel:transitGatewayRegistration:RegisterTransitGatewayResponse' :: RegisterTransitGatewayResponse -> Maybe TransitGatewayRegistration
transitGatewayRegistration} -> Maybe TransitGatewayRegistration
transitGatewayRegistration) (\s :: RegisterTransitGatewayResponse
s@RegisterTransitGatewayResponse' {} Maybe TransitGatewayRegistration
a -> RegisterTransitGatewayResponse
s {$sel:transitGatewayRegistration:RegisterTransitGatewayResponse' :: Maybe TransitGatewayRegistration
transitGatewayRegistration = Maybe TransitGatewayRegistration
a} :: RegisterTransitGatewayResponse)
registerTransitGatewayResponse_httpStatus :: Lens.Lens' RegisterTransitGatewayResponse Prelude.Int
registerTransitGatewayResponse_httpStatus :: Lens' RegisterTransitGatewayResponse Int
registerTransitGatewayResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterTransitGatewayResponse' {Int
httpStatus :: Int
$sel:httpStatus:RegisterTransitGatewayResponse' :: RegisterTransitGatewayResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: RegisterTransitGatewayResponse
s@RegisterTransitGatewayResponse' {} Int
a -> RegisterTransitGatewayResponse
s {$sel:httpStatus:RegisterTransitGatewayResponse' :: Int
httpStatus = Int
a} :: RegisterTransitGatewayResponse)
instance
Prelude.NFData
RegisterTransitGatewayResponse
where
rnf :: RegisterTransitGatewayResponse -> ()
rnf RegisterTransitGatewayResponse' {Int
Maybe TransitGatewayRegistration
httpStatus :: Int
transitGatewayRegistration :: Maybe TransitGatewayRegistration
$sel:httpStatus:RegisterTransitGatewayResponse' :: RegisterTransitGatewayResponse -> Int
$sel:transitGatewayRegistration:RegisterTransitGatewayResponse' :: RegisterTransitGatewayResponse -> Maybe TransitGatewayRegistration
..} =
forall a. NFData a => a -> ()
Prelude.rnf Maybe TransitGatewayRegistration
transitGatewayRegistration
seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus