{-# 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.CloudHSM.CreateHsm
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- This is documentation for __AWS CloudHSM Classic__. For more
-- information, see
-- <http://aws.amazon.com/cloudhsm/faqs-classic/ AWS CloudHSM Classic FAQs>,
-- the
-- <https://docs.aws.amazon.com/cloudhsm/classic/userguide/ AWS CloudHSM Classic User Guide>,
-- and the
-- <https://docs.aws.amazon.com/cloudhsm/classic/APIReference/ AWS CloudHSM Classic API Reference>.
--
-- __For information about the current version of AWS CloudHSM__, see
-- <http://aws.amazon.com/cloudhsm/ AWS CloudHSM>, the
-- <https://docs.aws.amazon.com/cloudhsm/latest/userguide/ AWS CloudHSM User Guide>,
-- and the
-- <https://docs.aws.amazon.com/cloudhsm/latest/APIReference/ AWS CloudHSM API Reference>.
--
-- Creates an uninitialized HSM instance.
--
-- There is an upfront fee charged for each HSM instance that you create
-- with the @CreateHsm@ operation. If you accidentally provision an HSM and
-- want to request a refund, delete the instance using the DeleteHsm
-- operation, go to the
-- <https://console.aws.amazon.com/support/home AWS Support Center>, create
-- a new case, and select __Account and Billing Support__.
--
-- It can take up to 20 minutes to create and provision an HSM. You can
-- monitor the status of the HSM with the DescribeHsm operation. The HSM is
-- ready to be initialized when the status changes to @RUNNING@.
module Amazonka.CloudHSM.CreateHsm
  ( -- * Creating a Request
    CreateHsm (..),
    newCreateHsm,

    -- * Request Lenses
    createHsm_clientToken,
    createHsm_eniIp,
    createHsm_externalId,
    createHsm_syslogIp,
    createHsm_subnetId,
    createHsm_sshKey,
    createHsm_iamRoleArn,
    createHsm_subscriptionType,

    -- * Destructuring the Response
    CreateHsmResponse (..),
    newCreateHsmResponse,

    -- * Response Lenses
    createHsmResponse_hsmArn,
    createHsmResponse_httpStatus,
  )
where

import Amazonka.CloudHSM.Types
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Contains the inputs for the @CreateHsm@ operation.
--
-- /See:/ 'newCreateHsm' smart constructor.
data CreateHsm = CreateHsm'
  { -- | A user-defined token to ensure idempotence. Subsequent calls to this
    -- operation with the same token will be ignored.
    CreateHsm -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The IP address to assign to the HSM\'s ENI.
    --
    -- If an IP address is not specified, an IP address will be randomly chosen
    -- from the CIDR range of the subnet.
    CreateHsm -> Maybe Text
eniIp :: Prelude.Maybe Prelude.Text,
    -- | The external ID from @IamRoleArn@, if present.
    CreateHsm -> Maybe Text
externalId :: Prelude.Maybe Prelude.Text,
    -- | The IP address for the syslog monitoring server. The AWS CloudHSM
    -- service only supports one syslog monitoring server.
    CreateHsm -> Maybe Text
syslogIp :: Prelude.Maybe Prelude.Text,
    -- | The identifier of the subnet in your VPC in which to place the HSM.
    CreateHsm -> Text
subnetId :: Prelude.Text,
    -- | The SSH public key to install on the HSM.
    CreateHsm -> Text
sshKey :: Prelude.Text,
    -- | The ARN of an IAM role to enable the AWS CloudHSM service to allocate an
    -- ENI on your behalf.
    CreateHsm -> Text
iamRoleArn :: Prelude.Text,
    CreateHsm -> SubscriptionType
subscriptionType :: SubscriptionType
  }
  deriving (CreateHsm -> CreateHsm -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateHsm -> CreateHsm -> Bool
$c/= :: CreateHsm -> CreateHsm -> Bool
== :: CreateHsm -> CreateHsm -> Bool
$c== :: CreateHsm -> CreateHsm -> Bool
Prelude.Eq, ReadPrec [CreateHsm]
ReadPrec CreateHsm
Int -> ReadS CreateHsm
ReadS [CreateHsm]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateHsm]
$creadListPrec :: ReadPrec [CreateHsm]
readPrec :: ReadPrec CreateHsm
$creadPrec :: ReadPrec CreateHsm
readList :: ReadS [CreateHsm]
$creadList :: ReadS [CreateHsm]
readsPrec :: Int -> ReadS CreateHsm
$creadsPrec :: Int -> ReadS CreateHsm
Prelude.Read, Int -> CreateHsm -> ShowS
[CreateHsm] -> ShowS
CreateHsm -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateHsm] -> ShowS
$cshowList :: [CreateHsm] -> ShowS
show :: CreateHsm -> String
$cshow :: CreateHsm -> String
showsPrec :: Int -> CreateHsm -> ShowS
$cshowsPrec :: Int -> CreateHsm -> ShowS
Prelude.Show, forall x. Rep CreateHsm x -> CreateHsm
forall x. CreateHsm -> Rep CreateHsm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateHsm x -> CreateHsm
$cfrom :: forall x. CreateHsm -> Rep CreateHsm x
Prelude.Generic)

-- |
-- Create a value of 'CreateHsm' 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:
--
-- 'clientToken', 'createHsm_clientToken' - A user-defined token to ensure idempotence. Subsequent calls to this
-- operation with the same token will be ignored.
--
-- 'eniIp', 'createHsm_eniIp' - The IP address to assign to the HSM\'s ENI.
--
-- If an IP address is not specified, an IP address will be randomly chosen
-- from the CIDR range of the subnet.
--
-- 'externalId', 'createHsm_externalId' - The external ID from @IamRoleArn@, if present.
--
-- 'syslogIp', 'createHsm_syslogIp' - The IP address for the syslog monitoring server. The AWS CloudHSM
-- service only supports one syslog monitoring server.
--
-- 'subnetId', 'createHsm_subnetId' - The identifier of the subnet in your VPC in which to place the HSM.
--
-- 'sshKey', 'createHsm_sshKey' - The SSH public key to install on the HSM.
--
-- 'iamRoleArn', 'createHsm_iamRoleArn' - The ARN of an IAM role to enable the AWS CloudHSM service to allocate an
-- ENI on your behalf.
--
-- 'subscriptionType', 'createHsm_subscriptionType' - Undocumented member.
newCreateHsm ::
  -- | 'subnetId'
  Prelude.Text ->
  -- | 'sshKey'
  Prelude.Text ->
  -- | 'iamRoleArn'
  Prelude.Text ->
  -- | 'subscriptionType'
  SubscriptionType ->
  CreateHsm
newCreateHsm :: Text -> Text -> Text -> SubscriptionType -> CreateHsm
newCreateHsm
  Text
pSubnetId_
  Text
pSshKey_
  Text
pIamRoleArn_
  SubscriptionType
pSubscriptionType_ =
    CreateHsm'
      { $sel:clientToken:CreateHsm' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
        $sel:eniIp:CreateHsm' :: Maybe Text
eniIp = forall a. Maybe a
Prelude.Nothing,
        $sel:externalId:CreateHsm' :: Maybe Text
externalId = forall a. Maybe a
Prelude.Nothing,
        $sel:syslogIp:CreateHsm' :: Maybe Text
syslogIp = forall a. Maybe a
Prelude.Nothing,
        $sel:subnetId:CreateHsm' :: Text
subnetId = Text
pSubnetId_,
        $sel:sshKey:CreateHsm' :: Text
sshKey = Text
pSshKey_,
        $sel:iamRoleArn:CreateHsm' :: Text
iamRoleArn = Text
pIamRoleArn_,
        $sel:subscriptionType:CreateHsm' :: SubscriptionType
subscriptionType = SubscriptionType
pSubscriptionType_
      }

-- | A user-defined token to ensure idempotence. Subsequent calls to this
-- operation with the same token will be ignored.
createHsm_clientToken :: Lens.Lens' CreateHsm (Prelude.Maybe Prelude.Text)
createHsm_clientToken :: Lens' CreateHsm (Maybe Text)
createHsm_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateHsm' :: CreateHsm -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateHsm
s@CreateHsm' {} Maybe Text
a -> CreateHsm
s {$sel:clientToken:CreateHsm' :: Maybe Text
clientToken = Maybe Text
a} :: CreateHsm)

-- | The IP address to assign to the HSM\'s ENI.
--
-- If an IP address is not specified, an IP address will be randomly chosen
-- from the CIDR range of the subnet.
createHsm_eniIp :: Lens.Lens' CreateHsm (Prelude.Maybe Prelude.Text)
createHsm_eniIp :: Lens' CreateHsm (Maybe Text)
createHsm_eniIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Maybe Text
eniIp :: Maybe Text
$sel:eniIp:CreateHsm' :: CreateHsm -> Maybe Text
eniIp} -> Maybe Text
eniIp) (\s :: CreateHsm
s@CreateHsm' {} Maybe Text
a -> CreateHsm
s {$sel:eniIp:CreateHsm' :: Maybe Text
eniIp = Maybe Text
a} :: CreateHsm)

-- | The external ID from @IamRoleArn@, if present.
createHsm_externalId :: Lens.Lens' CreateHsm (Prelude.Maybe Prelude.Text)
createHsm_externalId :: Lens' CreateHsm (Maybe Text)
createHsm_externalId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Maybe Text
externalId :: Maybe Text
$sel:externalId:CreateHsm' :: CreateHsm -> Maybe Text
externalId} -> Maybe Text
externalId) (\s :: CreateHsm
s@CreateHsm' {} Maybe Text
a -> CreateHsm
s {$sel:externalId:CreateHsm' :: Maybe Text
externalId = Maybe Text
a} :: CreateHsm)

-- | The IP address for the syslog monitoring server. The AWS CloudHSM
-- service only supports one syslog monitoring server.
createHsm_syslogIp :: Lens.Lens' CreateHsm (Prelude.Maybe Prelude.Text)
createHsm_syslogIp :: Lens' CreateHsm (Maybe Text)
createHsm_syslogIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Maybe Text
syslogIp :: Maybe Text
$sel:syslogIp:CreateHsm' :: CreateHsm -> Maybe Text
syslogIp} -> Maybe Text
syslogIp) (\s :: CreateHsm
s@CreateHsm' {} Maybe Text
a -> CreateHsm
s {$sel:syslogIp:CreateHsm' :: Maybe Text
syslogIp = Maybe Text
a} :: CreateHsm)

-- | The identifier of the subnet in your VPC in which to place the HSM.
createHsm_subnetId :: Lens.Lens' CreateHsm Prelude.Text
createHsm_subnetId :: Lens' CreateHsm Text
createHsm_subnetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Text
subnetId :: Text
$sel:subnetId:CreateHsm' :: CreateHsm -> Text
subnetId} -> Text
subnetId) (\s :: CreateHsm
s@CreateHsm' {} Text
a -> CreateHsm
s {$sel:subnetId:CreateHsm' :: Text
subnetId = Text
a} :: CreateHsm)

-- | The SSH public key to install on the HSM.
createHsm_sshKey :: Lens.Lens' CreateHsm Prelude.Text
createHsm_sshKey :: Lens' CreateHsm Text
createHsm_sshKey = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Text
sshKey :: Text
$sel:sshKey:CreateHsm' :: CreateHsm -> Text
sshKey} -> Text
sshKey) (\s :: CreateHsm
s@CreateHsm' {} Text
a -> CreateHsm
s {$sel:sshKey:CreateHsm' :: Text
sshKey = Text
a} :: CreateHsm)

-- | The ARN of an IAM role to enable the AWS CloudHSM service to allocate an
-- ENI on your behalf.
createHsm_iamRoleArn :: Lens.Lens' CreateHsm Prelude.Text
createHsm_iamRoleArn :: Lens' CreateHsm Text
createHsm_iamRoleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {Text
iamRoleArn :: Text
$sel:iamRoleArn:CreateHsm' :: CreateHsm -> Text
iamRoleArn} -> Text
iamRoleArn) (\s :: CreateHsm
s@CreateHsm' {} Text
a -> CreateHsm
s {$sel:iamRoleArn:CreateHsm' :: Text
iamRoleArn = Text
a} :: CreateHsm)

-- | Undocumented member.
createHsm_subscriptionType :: Lens.Lens' CreateHsm SubscriptionType
createHsm_subscriptionType :: Lens' CreateHsm SubscriptionType
createHsm_subscriptionType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsm' {SubscriptionType
subscriptionType :: SubscriptionType
$sel:subscriptionType:CreateHsm' :: CreateHsm -> SubscriptionType
subscriptionType} -> SubscriptionType
subscriptionType) (\s :: CreateHsm
s@CreateHsm' {} SubscriptionType
a -> CreateHsm
s {$sel:subscriptionType:CreateHsm' :: SubscriptionType
subscriptionType = SubscriptionType
a} :: CreateHsm)

instance Core.AWSRequest CreateHsm where
  type AWSResponse CreateHsm = CreateHsmResponse
  request :: (Service -> Service) -> CreateHsm -> Request CreateHsm
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 CreateHsm
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateHsm)))
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 Text -> Int -> CreateHsmResponse
CreateHsmResponse'
            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
"HsmArn")
            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 CreateHsm where
  hashWithSalt :: Int -> CreateHsm -> Int
hashWithSalt Int
_salt CreateHsm' {Maybe Text
Text
SubscriptionType
subscriptionType :: SubscriptionType
iamRoleArn :: Text
sshKey :: Text
subnetId :: Text
syslogIp :: Maybe Text
externalId :: Maybe Text
eniIp :: Maybe Text
clientToken :: Maybe Text
$sel:subscriptionType:CreateHsm' :: CreateHsm -> SubscriptionType
$sel:iamRoleArn:CreateHsm' :: CreateHsm -> Text
$sel:sshKey:CreateHsm' :: CreateHsm -> Text
$sel:subnetId:CreateHsm' :: CreateHsm -> Text
$sel:syslogIp:CreateHsm' :: CreateHsm -> Maybe Text
$sel:externalId:CreateHsm' :: CreateHsm -> Maybe Text
$sel:eniIp:CreateHsm' :: CreateHsm -> Maybe Text
$sel:clientToken:CreateHsm' :: CreateHsm -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eniIp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
externalId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
syslogIp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
subnetId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sshKey
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
iamRoleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SubscriptionType
subscriptionType

instance Prelude.NFData CreateHsm where
  rnf :: CreateHsm -> ()
rnf CreateHsm' {Maybe Text
Text
SubscriptionType
subscriptionType :: SubscriptionType
iamRoleArn :: Text
sshKey :: Text
subnetId :: Text
syslogIp :: Maybe Text
externalId :: Maybe Text
eniIp :: Maybe Text
clientToken :: Maybe Text
$sel:subscriptionType:CreateHsm' :: CreateHsm -> SubscriptionType
$sel:iamRoleArn:CreateHsm' :: CreateHsm -> Text
$sel:sshKey:CreateHsm' :: CreateHsm -> Text
$sel:subnetId:CreateHsm' :: CreateHsm -> Text
$sel:syslogIp:CreateHsm' :: CreateHsm -> Maybe Text
$sel:externalId:CreateHsm' :: CreateHsm -> Maybe Text
$sel:eniIp:CreateHsm' :: CreateHsm -> Maybe Text
$sel:clientToken:CreateHsm' :: CreateHsm -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eniIp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
externalId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
syslogIp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
subnetId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
sshKey
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
iamRoleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf SubscriptionType
subscriptionType

instance Data.ToHeaders CreateHsm where
  toHeaders :: CreateHsm -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"CloudHsmFrontendService.CreateHsm" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateHsm where
  toJSON :: CreateHsm -> Value
toJSON CreateHsm' {Maybe Text
Text
SubscriptionType
subscriptionType :: SubscriptionType
iamRoleArn :: Text
sshKey :: Text
subnetId :: Text
syslogIp :: Maybe Text
externalId :: Maybe Text
eniIp :: Maybe Text
clientToken :: Maybe Text
$sel:subscriptionType:CreateHsm' :: CreateHsm -> SubscriptionType
$sel:iamRoleArn:CreateHsm' :: CreateHsm -> Text
$sel:sshKey:CreateHsm' :: CreateHsm -> Text
$sel:subnetId:CreateHsm' :: CreateHsm -> Text
$sel:syslogIp:CreateHsm' :: CreateHsm -> Maybe Text
$sel:externalId:CreateHsm' :: CreateHsm -> Maybe Text
$sel:eniIp:CreateHsm' :: CreateHsm -> Maybe Text
$sel:clientToken:CreateHsm' :: CreateHsm -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clientToken,
            (Key
"EniIp" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
eniIp,
            (Key
"ExternalId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
externalId,
            (Key
"SyslogIp" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
syslogIp,
            forall a. a -> Maybe a
Prelude.Just (Key
"SubnetId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
subnetId),
            forall a. a -> Maybe a
Prelude.Just (Key
"SshKey" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sshKey),
            forall a. a -> Maybe a
Prelude.Just (Key
"IamRoleArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
iamRoleArn),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"SubscriptionType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SubscriptionType
subscriptionType)
          ]
      )

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

instance Data.ToQuery CreateHsm where
  toQuery :: CreateHsm -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | Contains the output of the @CreateHsm@ operation.
--
-- /See:/ 'newCreateHsmResponse' smart constructor.
data CreateHsmResponse = CreateHsmResponse'
  { -- | The ARN of the HSM.
    CreateHsmResponse -> Maybe Text
hsmArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateHsmResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateHsmResponse -> CreateHsmResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateHsmResponse -> CreateHsmResponse -> Bool
$c/= :: CreateHsmResponse -> CreateHsmResponse -> Bool
== :: CreateHsmResponse -> CreateHsmResponse -> Bool
$c== :: CreateHsmResponse -> CreateHsmResponse -> Bool
Prelude.Eq, ReadPrec [CreateHsmResponse]
ReadPrec CreateHsmResponse
Int -> ReadS CreateHsmResponse
ReadS [CreateHsmResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateHsmResponse]
$creadListPrec :: ReadPrec [CreateHsmResponse]
readPrec :: ReadPrec CreateHsmResponse
$creadPrec :: ReadPrec CreateHsmResponse
readList :: ReadS [CreateHsmResponse]
$creadList :: ReadS [CreateHsmResponse]
readsPrec :: Int -> ReadS CreateHsmResponse
$creadsPrec :: Int -> ReadS CreateHsmResponse
Prelude.Read, Int -> CreateHsmResponse -> ShowS
[CreateHsmResponse] -> ShowS
CreateHsmResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateHsmResponse] -> ShowS
$cshowList :: [CreateHsmResponse] -> ShowS
show :: CreateHsmResponse -> String
$cshow :: CreateHsmResponse -> String
showsPrec :: Int -> CreateHsmResponse -> ShowS
$cshowsPrec :: Int -> CreateHsmResponse -> ShowS
Prelude.Show, forall x. Rep CreateHsmResponse x -> CreateHsmResponse
forall x. CreateHsmResponse -> Rep CreateHsmResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateHsmResponse x -> CreateHsmResponse
$cfrom :: forall x. CreateHsmResponse -> Rep CreateHsmResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateHsmResponse' 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:
--
-- 'hsmArn', 'createHsmResponse_hsmArn' - The ARN of the HSM.
--
-- 'httpStatus', 'createHsmResponse_httpStatus' - The response's http status code.
newCreateHsmResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateHsmResponse
newCreateHsmResponse :: Int -> CreateHsmResponse
newCreateHsmResponse Int
pHttpStatus_ =
  CreateHsmResponse'
    { $sel:hsmArn:CreateHsmResponse' :: Maybe Text
hsmArn = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateHsmResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the HSM.
createHsmResponse_hsmArn :: Lens.Lens' CreateHsmResponse (Prelude.Maybe Prelude.Text)
createHsmResponse_hsmArn :: Lens' CreateHsmResponse (Maybe Text)
createHsmResponse_hsmArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateHsmResponse' {Maybe Text
hsmArn :: Maybe Text
$sel:hsmArn:CreateHsmResponse' :: CreateHsmResponse -> Maybe Text
hsmArn} -> Maybe Text
hsmArn) (\s :: CreateHsmResponse
s@CreateHsmResponse' {} Maybe Text
a -> CreateHsmResponse
s {$sel:hsmArn:CreateHsmResponse' :: Maybe Text
hsmArn = Maybe Text
a} :: CreateHsmResponse)

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

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