{-# 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.MemoryDb.CreateCluster
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a cluster. All nodes in the cluster run the same
-- protocol-compliant engine software.
module Amazonka.MemoryDb.CreateCluster
  ( -- * Creating a Request
    CreateCluster (..),
    newCreateCluster,

    -- * Request Lenses
    createCluster_engineVersion,
    createCluster_securityGroupIds,
    createCluster_snapshotArns,
    createCluster_autoMinorVersionUpgrade,
    createCluster_snsTopicArn,
    createCluster_snapshotWindow,
    createCluster_subnetGroupName,
    createCluster_tLSEnabled,
    createCluster_numShards,
    createCluster_maintenanceWindow,
    createCluster_kmsKeyId,
    createCluster_snapshotRetentionLimit,
    createCluster_snapshotName,
    createCluster_description,
    createCluster_numReplicasPerShard,
    createCluster_tags,
    createCluster_port,
    createCluster_parameterGroupName,
    createCluster_clusterName,
    createCluster_nodeType,
    createCluster_aCLName,

    -- * Destructuring the Response
    CreateClusterResponse (..),
    newCreateClusterResponse,

    -- * Response Lenses
    createClusterResponse_cluster,
    createClusterResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MemoryDb.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateCluster' smart constructor.
data CreateCluster = CreateCluster'
  { -- | The version number of the Redis engine to be used for the cluster.
    CreateCluster -> Maybe Text
engineVersion :: Prelude.Maybe Prelude.Text,
    -- | A list of security group names to associate with this cluster.
    CreateCluster -> Maybe [Text]
securityGroupIds :: Prelude.Maybe [Prelude.Text],
    -- | A list of Amazon Resource Names (ARN) that uniquely identify the RDB
    -- snapshot files stored in Amazon S3. The snapshot files are used to
    -- populate the new cluster. The Amazon S3 object name in the ARN cannot
    -- contain any commas.
    CreateCluster -> Maybe [Text]
snapshotArns :: Prelude.Maybe [Prelude.Text],
    -- | When set to true, the cluster will automatically receive minor engine
    -- version upgrades after launch.
    CreateCluster -> Maybe Bool
autoMinorVersionUpgrade :: Prelude.Maybe Prelude.Bool,
    -- | The Amazon Resource Name (ARN) of the Amazon Simple Notification Service
    -- (SNS) topic to which notifications are sent.
    CreateCluster -> Maybe Text
snsTopicArn :: Prelude.Maybe Prelude.Text,
    -- | The daily time range (in UTC) during which MemoryDB begins taking a
    -- daily snapshot of your shard.
    --
    -- Example: 05:00-09:00
    --
    -- If you do not specify this parameter, MemoryDB automatically chooses an
    -- appropriate time range.
    CreateCluster -> Maybe Text
snapshotWindow :: Prelude.Maybe Prelude.Text,
    -- | The name of the subnet group to be used for the cluster.
    CreateCluster -> Maybe Text
subnetGroupName :: Prelude.Maybe Prelude.Text,
    -- | A flag to enable in-transit encryption on the cluster.
    CreateCluster -> Maybe Bool
tLSEnabled :: Prelude.Maybe Prelude.Bool,
    -- | The number of shards the cluster will contain. The default value is 1.
    CreateCluster -> Maybe Int
numShards :: Prelude.Maybe Prelude.Int,
    -- | Specifies the weekly time range during which maintenance on the cluster
    -- is performed. It is specified as a range in the format
    -- @ddd:hh24:mi-ddd:hh24:mi@ (24H Clock UTC). The minimum maintenance
    -- window is a 60 minute period.
    CreateCluster -> Maybe Text
maintenanceWindow :: Prelude.Maybe Prelude.Text,
    -- | The ID of the KMS key used to encrypt the cluster.
    CreateCluster -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | The number of days for which MemoryDB retains automatic snapshots before
    -- deleting them. For example, if you set SnapshotRetentionLimit to 5, a
    -- snapshot that was taken today is retained for 5 days before being
    -- deleted.
    CreateCluster -> Maybe Int
snapshotRetentionLimit :: Prelude.Maybe Prelude.Int,
    -- | The name of a snapshot from which to restore data into the new cluster.
    -- The snapshot status changes to restoring while the new cluster is being
    -- created.
    CreateCluster -> Maybe Text
snapshotName :: Prelude.Maybe Prelude.Text,
    -- | An optional description of the cluster.
    CreateCluster -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The number of replicas to apply to each shard. The default value is 1.
    -- The maximum is 5.
    CreateCluster -> Maybe Int
numReplicasPerShard :: Prelude.Maybe Prelude.Int,
    -- | A list of tags to be added to this resource. Tags are comma-separated
    -- key,value pairs (e.g. Key=myKey, Value=myKeyValue. You can include
    -- multiple tags as shown following: Key=myKey, Value=myKeyValue
    -- Key=mySecondKey, Value=mySecondKeyValue.
    CreateCluster -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The port number on which each of the nodes accepts connections.
    CreateCluster -> Maybe Int
port :: Prelude.Maybe Prelude.Int,
    -- | The name of the parameter group associated with the cluster.
    CreateCluster -> Maybe Text
parameterGroupName :: Prelude.Maybe Prelude.Text,
    -- | The name of the cluster. This value must be unique as it also serves as
    -- the cluster identifier.
    CreateCluster -> Text
clusterName :: Prelude.Text,
    -- | The compute and memory capacity of the nodes in the cluster.
    CreateCluster -> Text
nodeType :: Prelude.Text,
    -- | The name of the Access Control List to associate with the cluster.
    CreateCluster -> Text
aCLName :: Prelude.Text
  }
  deriving (CreateCluster -> CreateCluster -> Bool
(CreateCluster -> CreateCluster -> Bool)
-> (CreateCluster -> CreateCluster -> Bool) -> Eq CreateCluster
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCluster -> CreateCluster -> Bool
$c/= :: CreateCluster -> CreateCluster -> Bool
== :: CreateCluster -> CreateCluster -> Bool
$c== :: CreateCluster -> CreateCluster -> Bool
Prelude.Eq, ReadPrec [CreateCluster]
ReadPrec CreateCluster
Int -> ReadS CreateCluster
ReadS [CreateCluster]
(Int -> ReadS CreateCluster)
-> ReadS [CreateCluster]
-> ReadPrec CreateCluster
-> ReadPrec [CreateCluster]
-> Read CreateCluster
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCluster]
$creadListPrec :: ReadPrec [CreateCluster]
readPrec :: ReadPrec CreateCluster
$creadPrec :: ReadPrec CreateCluster
readList :: ReadS [CreateCluster]
$creadList :: ReadS [CreateCluster]
readsPrec :: Int -> ReadS CreateCluster
$creadsPrec :: Int -> ReadS CreateCluster
Prelude.Read, Int -> CreateCluster -> ShowS
[CreateCluster] -> ShowS
CreateCluster -> String
(Int -> CreateCluster -> ShowS)
-> (CreateCluster -> String)
-> ([CreateCluster] -> ShowS)
-> Show CreateCluster
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCluster] -> ShowS
$cshowList :: [CreateCluster] -> ShowS
show :: CreateCluster -> String
$cshow :: CreateCluster -> String
showsPrec :: Int -> CreateCluster -> ShowS
$cshowsPrec :: Int -> CreateCluster -> ShowS
Prelude.Show, (forall x. CreateCluster -> Rep CreateCluster x)
-> (forall x. Rep CreateCluster x -> CreateCluster)
-> Generic CreateCluster
forall x. Rep CreateCluster x -> CreateCluster
forall x. CreateCluster -> Rep CreateCluster x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateCluster x -> CreateCluster
$cfrom :: forall x. CreateCluster -> Rep CreateCluster x
Prelude.Generic)

-- |
-- Create a value of 'CreateCluster' 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:
--
-- 'engineVersion', 'createCluster_engineVersion' - The version number of the Redis engine to be used for the cluster.
--
-- 'securityGroupIds', 'createCluster_securityGroupIds' - A list of security group names to associate with this cluster.
--
-- 'snapshotArns', 'createCluster_snapshotArns' - A list of Amazon Resource Names (ARN) that uniquely identify the RDB
-- snapshot files stored in Amazon S3. The snapshot files are used to
-- populate the new cluster. The Amazon S3 object name in the ARN cannot
-- contain any commas.
--
-- 'autoMinorVersionUpgrade', 'createCluster_autoMinorVersionUpgrade' - When set to true, the cluster will automatically receive minor engine
-- version upgrades after launch.
--
-- 'snsTopicArn', 'createCluster_snsTopicArn' - The Amazon Resource Name (ARN) of the Amazon Simple Notification Service
-- (SNS) topic to which notifications are sent.
--
-- 'snapshotWindow', 'createCluster_snapshotWindow' - The daily time range (in UTC) during which MemoryDB begins taking a
-- daily snapshot of your shard.
--
-- Example: 05:00-09:00
--
-- If you do not specify this parameter, MemoryDB automatically chooses an
-- appropriate time range.
--
-- 'subnetGroupName', 'createCluster_subnetGroupName' - The name of the subnet group to be used for the cluster.
--
-- 'tLSEnabled', 'createCluster_tLSEnabled' - A flag to enable in-transit encryption on the cluster.
--
-- 'numShards', 'createCluster_numShards' - The number of shards the cluster will contain. The default value is 1.
--
-- 'maintenanceWindow', 'createCluster_maintenanceWindow' - Specifies the weekly time range during which maintenance on the cluster
-- is performed. It is specified as a range in the format
-- @ddd:hh24:mi-ddd:hh24:mi@ (24H Clock UTC). The minimum maintenance
-- window is a 60 minute period.
--
-- 'kmsKeyId', 'createCluster_kmsKeyId' - The ID of the KMS key used to encrypt the cluster.
--
-- 'snapshotRetentionLimit', 'createCluster_snapshotRetentionLimit' - The number of days for which MemoryDB retains automatic snapshots before
-- deleting them. For example, if you set SnapshotRetentionLimit to 5, a
-- snapshot that was taken today is retained for 5 days before being
-- deleted.
--
-- 'snapshotName', 'createCluster_snapshotName' - The name of a snapshot from which to restore data into the new cluster.
-- The snapshot status changes to restoring while the new cluster is being
-- created.
--
-- 'description', 'createCluster_description' - An optional description of the cluster.
--
-- 'numReplicasPerShard', 'createCluster_numReplicasPerShard' - The number of replicas to apply to each shard. The default value is 1.
-- The maximum is 5.
--
-- 'tags', 'createCluster_tags' - A list of tags to be added to this resource. Tags are comma-separated
-- key,value pairs (e.g. Key=myKey, Value=myKeyValue. You can include
-- multiple tags as shown following: Key=myKey, Value=myKeyValue
-- Key=mySecondKey, Value=mySecondKeyValue.
--
-- 'port', 'createCluster_port' - The port number on which each of the nodes accepts connections.
--
-- 'parameterGroupName', 'createCluster_parameterGroupName' - The name of the parameter group associated with the cluster.
--
-- 'clusterName', 'createCluster_clusterName' - The name of the cluster. This value must be unique as it also serves as
-- the cluster identifier.
--
-- 'nodeType', 'createCluster_nodeType' - The compute and memory capacity of the nodes in the cluster.
--
-- 'aCLName', 'createCluster_aCLName' - The name of the Access Control List to associate with the cluster.
newCreateCluster ::
  -- | 'clusterName'
  Prelude.Text ->
  -- | 'nodeType'
  Prelude.Text ->
  -- | 'aCLName'
  Prelude.Text ->
  CreateCluster
newCreateCluster :: Text -> Text -> Text -> CreateCluster
newCreateCluster Text
pClusterName_ Text
pNodeType_ Text
pACLName_ =
  CreateCluster' :: Maybe Text
-> Maybe [Text]
-> Maybe [Text]
-> Maybe Bool
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe [Tag]
-> Maybe Int
-> Maybe Text
-> Text
-> Text
-> Text
-> CreateCluster
CreateCluster'
    { $sel:engineVersion:CreateCluster' :: Maybe Text
engineVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:securityGroupIds:CreateCluster' :: Maybe [Text]
securityGroupIds = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotArns:CreateCluster' :: Maybe [Text]
snapshotArns = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:autoMinorVersionUpgrade:CreateCluster' :: Maybe Bool
autoMinorVersionUpgrade = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:snsTopicArn:CreateCluster' :: Maybe Text
snsTopicArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotWindow:CreateCluster' :: Maybe Text
snapshotWindow = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:subnetGroupName:CreateCluster' :: Maybe Text
subnetGroupName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tLSEnabled:CreateCluster' :: Maybe Bool
tLSEnabled = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:numShards:CreateCluster' :: Maybe Int
numShards = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:maintenanceWindow:CreateCluster' :: Maybe Text
maintenanceWindow = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:kmsKeyId:CreateCluster' :: Maybe Text
kmsKeyId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotRetentionLimit:CreateCluster' :: Maybe Int
snapshotRetentionLimit = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotName:CreateCluster' :: Maybe Text
snapshotName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateCluster' :: Maybe Text
description = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:numReplicasPerShard:CreateCluster' :: Maybe Int
numReplicasPerShard = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateCluster' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
      $sel:port:CreateCluster' :: Maybe Int
port = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:parameterGroupName:CreateCluster' :: Maybe Text
parameterGroupName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:clusterName:CreateCluster' :: Text
clusterName = Text
pClusterName_,
      $sel:nodeType:CreateCluster' :: Text
nodeType = Text
pNodeType_,
      $sel:aCLName:CreateCluster' :: Text
aCLName = Text
pACLName_
    }

-- | The version number of the Redis engine to be used for the cluster.
createCluster_engineVersion :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_engineVersion :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_engineVersion = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
engineVersion :: Maybe Text
$sel:engineVersion:CreateCluster' :: CreateCluster -> Maybe Text
engineVersion} -> Maybe Text
engineVersion) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:engineVersion:CreateCluster' :: Maybe Text
engineVersion = Maybe Text
a} :: CreateCluster)

-- | A list of security group names to associate with this cluster.
createCluster_securityGroupIds :: Lens.Lens' CreateCluster (Prelude.Maybe [Prelude.Text])
createCluster_securityGroupIds :: (Maybe [Text] -> f (Maybe [Text]))
-> CreateCluster -> f CreateCluster
createCluster_securityGroupIds = (CreateCluster -> Maybe [Text])
-> (CreateCluster -> Maybe [Text] -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe [Text]
securityGroupIds :: Maybe [Text]
$sel:securityGroupIds:CreateCluster' :: CreateCluster -> Maybe [Text]
securityGroupIds} -> Maybe [Text]
securityGroupIds) (\s :: CreateCluster
s@CreateCluster' {} Maybe [Text]
a -> CreateCluster
s {$sel:securityGroupIds:CreateCluster' :: Maybe [Text]
securityGroupIds = Maybe [Text]
a} :: CreateCluster) ((Maybe [Text] -> f (Maybe [Text]))
 -> CreateCluster -> f CreateCluster)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> CreateCluster
-> f CreateCluster
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of Amazon Resource Names (ARN) that uniquely identify the RDB
-- snapshot files stored in Amazon S3. The snapshot files are used to
-- populate the new cluster. The Amazon S3 object name in the ARN cannot
-- contain any commas.
createCluster_snapshotArns :: Lens.Lens' CreateCluster (Prelude.Maybe [Prelude.Text])
createCluster_snapshotArns :: (Maybe [Text] -> f (Maybe [Text]))
-> CreateCluster -> f CreateCluster
createCluster_snapshotArns = (CreateCluster -> Maybe [Text])
-> (CreateCluster -> Maybe [Text] -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe [Text]
snapshotArns :: Maybe [Text]
$sel:snapshotArns:CreateCluster' :: CreateCluster -> Maybe [Text]
snapshotArns} -> Maybe [Text]
snapshotArns) (\s :: CreateCluster
s@CreateCluster' {} Maybe [Text]
a -> CreateCluster
s {$sel:snapshotArns:CreateCluster' :: Maybe [Text]
snapshotArns = Maybe [Text]
a} :: CreateCluster) ((Maybe [Text] -> f (Maybe [Text]))
 -> CreateCluster -> f CreateCluster)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> CreateCluster
-> f CreateCluster
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | When set to true, the cluster will automatically receive minor engine
-- version upgrades after launch.
createCluster_autoMinorVersionUpgrade :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Bool)
createCluster_autoMinorVersionUpgrade :: (Maybe Bool -> f (Maybe Bool)) -> CreateCluster -> f CreateCluster
createCluster_autoMinorVersionUpgrade = (CreateCluster -> Maybe Bool)
-> (CreateCluster -> Maybe Bool -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Bool
autoMinorVersionUpgrade :: Maybe Bool
$sel:autoMinorVersionUpgrade:CreateCluster' :: CreateCluster -> Maybe Bool
autoMinorVersionUpgrade} -> Maybe Bool
autoMinorVersionUpgrade) (\s :: CreateCluster
s@CreateCluster' {} Maybe Bool
a -> CreateCluster
s {$sel:autoMinorVersionUpgrade:CreateCluster' :: Maybe Bool
autoMinorVersionUpgrade = Maybe Bool
a} :: CreateCluster)

-- | The Amazon Resource Name (ARN) of the Amazon Simple Notification Service
-- (SNS) topic to which notifications are sent.
createCluster_snsTopicArn :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_snsTopicArn :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_snsTopicArn = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
snsTopicArn :: Maybe Text
$sel:snsTopicArn:CreateCluster' :: CreateCluster -> Maybe Text
snsTopicArn} -> Maybe Text
snsTopicArn) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:snsTopicArn:CreateCluster' :: Maybe Text
snsTopicArn = Maybe Text
a} :: CreateCluster)

-- | The daily time range (in UTC) during which MemoryDB begins taking a
-- daily snapshot of your shard.
--
-- Example: 05:00-09:00
--
-- If you do not specify this parameter, MemoryDB automatically chooses an
-- appropriate time range.
createCluster_snapshotWindow :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_snapshotWindow :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_snapshotWindow = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
snapshotWindow :: Maybe Text
$sel:snapshotWindow:CreateCluster' :: CreateCluster -> Maybe Text
snapshotWindow} -> Maybe Text
snapshotWindow) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:snapshotWindow:CreateCluster' :: Maybe Text
snapshotWindow = Maybe Text
a} :: CreateCluster)

-- | The name of the subnet group to be used for the cluster.
createCluster_subnetGroupName :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_subnetGroupName :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_subnetGroupName = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
subnetGroupName :: Maybe Text
$sel:subnetGroupName:CreateCluster' :: CreateCluster -> Maybe Text
subnetGroupName} -> Maybe Text
subnetGroupName) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:subnetGroupName:CreateCluster' :: Maybe Text
subnetGroupName = Maybe Text
a} :: CreateCluster)

-- | A flag to enable in-transit encryption on the cluster.
createCluster_tLSEnabled :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Bool)
createCluster_tLSEnabled :: (Maybe Bool -> f (Maybe Bool)) -> CreateCluster -> f CreateCluster
createCluster_tLSEnabled = (CreateCluster -> Maybe Bool)
-> (CreateCluster -> Maybe Bool -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Bool
tLSEnabled :: Maybe Bool
$sel:tLSEnabled:CreateCluster' :: CreateCluster -> Maybe Bool
tLSEnabled} -> Maybe Bool
tLSEnabled) (\s :: CreateCluster
s@CreateCluster' {} Maybe Bool
a -> CreateCluster
s {$sel:tLSEnabled:CreateCluster' :: Maybe Bool
tLSEnabled = Maybe Bool
a} :: CreateCluster)

-- | The number of shards the cluster will contain. The default value is 1.
createCluster_numShards :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Int)
createCluster_numShards :: (Maybe Int -> f (Maybe Int)) -> CreateCluster -> f CreateCluster
createCluster_numShards = (CreateCluster -> Maybe Int)
-> (CreateCluster -> Maybe Int -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Int
numShards :: Maybe Int
$sel:numShards:CreateCluster' :: CreateCluster -> Maybe Int
numShards} -> Maybe Int
numShards) (\s :: CreateCluster
s@CreateCluster' {} Maybe Int
a -> CreateCluster
s {$sel:numShards:CreateCluster' :: Maybe Int
numShards = Maybe Int
a} :: CreateCluster)

-- | Specifies the weekly time range during which maintenance on the cluster
-- is performed. It is specified as a range in the format
-- @ddd:hh24:mi-ddd:hh24:mi@ (24H Clock UTC). The minimum maintenance
-- window is a 60 minute period.
createCluster_maintenanceWindow :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_maintenanceWindow :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_maintenanceWindow = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
maintenanceWindow :: Maybe Text
$sel:maintenanceWindow:CreateCluster' :: CreateCluster -> Maybe Text
maintenanceWindow} -> Maybe Text
maintenanceWindow) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:maintenanceWindow:CreateCluster' :: Maybe Text
maintenanceWindow = Maybe Text
a} :: CreateCluster)

-- | The ID of the KMS key used to encrypt the cluster.
createCluster_kmsKeyId :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_kmsKeyId :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_kmsKeyId = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:CreateCluster' :: CreateCluster -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:kmsKeyId:CreateCluster' :: Maybe Text
kmsKeyId = Maybe Text
a} :: CreateCluster)

-- | The number of days for which MemoryDB retains automatic snapshots before
-- deleting them. For example, if you set SnapshotRetentionLimit to 5, a
-- snapshot that was taken today is retained for 5 days before being
-- deleted.
createCluster_snapshotRetentionLimit :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Int)
createCluster_snapshotRetentionLimit :: (Maybe Int -> f (Maybe Int)) -> CreateCluster -> f CreateCluster
createCluster_snapshotRetentionLimit = (CreateCluster -> Maybe Int)
-> (CreateCluster -> Maybe Int -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Int
snapshotRetentionLimit :: Maybe Int
$sel:snapshotRetentionLimit:CreateCluster' :: CreateCluster -> Maybe Int
snapshotRetentionLimit} -> Maybe Int
snapshotRetentionLimit) (\s :: CreateCluster
s@CreateCluster' {} Maybe Int
a -> CreateCluster
s {$sel:snapshotRetentionLimit:CreateCluster' :: Maybe Int
snapshotRetentionLimit = Maybe Int
a} :: CreateCluster)

-- | The name of a snapshot from which to restore data into the new cluster.
-- The snapshot status changes to restoring while the new cluster is being
-- created.
createCluster_snapshotName :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_snapshotName :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_snapshotName = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
snapshotName :: Maybe Text
$sel:snapshotName:CreateCluster' :: CreateCluster -> Maybe Text
snapshotName} -> Maybe Text
snapshotName) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:snapshotName:CreateCluster' :: Maybe Text
snapshotName = Maybe Text
a} :: CreateCluster)

-- | An optional description of the cluster.
createCluster_description :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_description :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_description = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
description :: Maybe Text
$sel:description:CreateCluster' :: CreateCluster -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:description:CreateCluster' :: Maybe Text
description = Maybe Text
a} :: CreateCluster)

-- | The number of replicas to apply to each shard. The default value is 1.
-- The maximum is 5.
createCluster_numReplicasPerShard :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Int)
createCluster_numReplicasPerShard :: (Maybe Int -> f (Maybe Int)) -> CreateCluster -> f CreateCluster
createCluster_numReplicasPerShard = (CreateCluster -> Maybe Int)
-> (CreateCluster -> Maybe Int -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Int
numReplicasPerShard :: Maybe Int
$sel:numReplicasPerShard:CreateCluster' :: CreateCluster -> Maybe Int
numReplicasPerShard} -> Maybe Int
numReplicasPerShard) (\s :: CreateCluster
s@CreateCluster' {} Maybe Int
a -> CreateCluster
s {$sel:numReplicasPerShard:CreateCluster' :: Maybe Int
numReplicasPerShard = Maybe Int
a} :: CreateCluster)

-- | A list of tags to be added to this resource. Tags are comma-separated
-- key,value pairs (e.g. Key=myKey, Value=myKeyValue. You can include
-- multiple tags as shown following: Key=myKey, Value=myKeyValue
-- Key=mySecondKey, Value=mySecondKeyValue.
createCluster_tags :: Lens.Lens' CreateCluster (Prelude.Maybe [Tag])
createCluster_tags :: (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateCluster -> f CreateCluster
createCluster_tags = (CreateCluster -> Maybe [Tag])
-> (CreateCluster -> Maybe [Tag] -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe [Tag]) (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateCluster' :: CreateCluster -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateCluster
s@CreateCluster' {} Maybe [Tag]
a -> CreateCluster
s {$sel:tags:CreateCluster' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateCluster) ((Maybe [Tag] -> f (Maybe [Tag]))
 -> CreateCluster -> f CreateCluster)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateCluster
-> f CreateCluster
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The port number on which each of the nodes accepts connections.
createCluster_port :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Int)
createCluster_port :: (Maybe Int -> f (Maybe Int)) -> CreateCluster -> f CreateCluster
createCluster_port = (CreateCluster -> Maybe Int)
-> (CreateCluster -> Maybe Int -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Int
port :: Maybe Int
$sel:port:CreateCluster' :: CreateCluster -> Maybe Int
port} -> Maybe Int
port) (\s :: CreateCluster
s@CreateCluster' {} Maybe Int
a -> CreateCluster
s {$sel:port:CreateCluster' :: Maybe Int
port = Maybe Int
a} :: CreateCluster)

-- | The name of the parameter group associated with the cluster.
createCluster_parameterGroupName :: Lens.Lens' CreateCluster (Prelude.Maybe Prelude.Text)
createCluster_parameterGroupName :: (Maybe Text -> f (Maybe Text)) -> CreateCluster -> f CreateCluster
createCluster_parameterGroupName = (CreateCluster -> Maybe Text)
-> (CreateCluster -> Maybe Text -> CreateCluster)
-> Lens CreateCluster CreateCluster (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Maybe Text
parameterGroupName :: Maybe Text
$sel:parameterGroupName:CreateCluster' :: CreateCluster -> Maybe Text
parameterGroupName} -> Maybe Text
parameterGroupName) (\s :: CreateCluster
s@CreateCluster' {} Maybe Text
a -> CreateCluster
s {$sel:parameterGroupName:CreateCluster' :: Maybe Text
parameterGroupName = Maybe Text
a} :: CreateCluster)

-- | The name of the cluster. This value must be unique as it also serves as
-- the cluster identifier.
createCluster_clusterName :: Lens.Lens' CreateCluster Prelude.Text
createCluster_clusterName :: (Text -> f Text) -> CreateCluster -> f CreateCluster
createCluster_clusterName = (CreateCluster -> Text)
-> (CreateCluster -> Text -> CreateCluster)
-> Lens CreateCluster CreateCluster Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Text
clusterName :: Text
$sel:clusterName:CreateCluster' :: CreateCluster -> Text
clusterName} -> Text
clusterName) (\s :: CreateCluster
s@CreateCluster' {} Text
a -> CreateCluster
s {$sel:clusterName:CreateCluster' :: Text
clusterName = Text
a} :: CreateCluster)

-- | The compute and memory capacity of the nodes in the cluster.
createCluster_nodeType :: Lens.Lens' CreateCluster Prelude.Text
createCluster_nodeType :: (Text -> f Text) -> CreateCluster -> f CreateCluster
createCluster_nodeType = (CreateCluster -> Text)
-> (CreateCluster -> Text -> CreateCluster)
-> Lens CreateCluster CreateCluster Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Text
nodeType :: Text
$sel:nodeType:CreateCluster' :: CreateCluster -> Text
nodeType} -> Text
nodeType) (\s :: CreateCluster
s@CreateCluster' {} Text
a -> CreateCluster
s {$sel:nodeType:CreateCluster' :: Text
nodeType = Text
a} :: CreateCluster)

-- | The name of the Access Control List to associate with the cluster.
createCluster_aCLName :: Lens.Lens' CreateCluster Prelude.Text
createCluster_aCLName :: (Text -> f Text) -> CreateCluster -> f CreateCluster
createCluster_aCLName = (CreateCluster -> Text)
-> (CreateCluster -> Text -> CreateCluster)
-> Lens CreateCluster CreateCluster Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCluster' {Text
aCLName :: Text
$sel:aCLName:CreateCluster' :: CreateCluster -> Text
aCLName} -> Text
aCLName) (\s :: CreateCluster
s@CreateCluster' {} Text
a -> CreateCluster
s {$sel:aCLName:CreateCluster' :: Text
aCLName = Text
a} :: CreateCluster)

instance Core.AWSRequest CreateCluster where
  type
    AWSResponse CreateCluster =
      CreateClusterResponse
  request :: CreateCluster -> Request CreateCluster
request = Service -> CreateCluster -> Request CreateCluster
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CreateCluster
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateCluster)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CreateCluster))
-> Logger
-> Service
-> Proxy CreateCluster
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateCluster)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Cluster -> Int -> CreateClusterResponse
CreateClusterResponse'
            (Maybe Cluster -> Int -> CreateClusterResponse)
-> Either String (Maybe Cluster)
-> Either String (Int -> CreateClusterResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Cluster)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Cluster")
            Either String (Int -> CreateClusterResponse)
-> Either String Int -> Either String CreateClusterResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateCluster

instance Prelude.NFData CreateCluster

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

instance Core.ToJSON CreateCluster where
  toJSON :: CreateCluster -> Value
toJSON CreateCluster' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [Tag]
Maybe Text
Text
aCLName :: Text
nodeType :: Text
clusterName :: Text
parameterGroupName :: Maybe Text
port :: Maybe Int
tags :: Maybe [Tag]
numReplicasPerShard :: Maybe Int
description :: Maybe Text
snapshotName :: Maybe Text
snapshotRetentionLimit :: Maybe Int
kmsKeyId :: Maybe Text
maintenanceWindow :: Maybe Text
numShards :: Maybe Int
tLSEnabled :: Maybe Bool
subnetGroupName :: Maybe Text
snapshotWindow :: Maybe Text
snsTopicArn :: Maybe Text
autoMinorVersionUpgrade :: Maybe Bool
snapshotArns :: Maybe [Text]
securityGroupIds :: Maybe [Text]
engineVersion :: Maybe Text
$sel:aCLName:CreateCluster' :: CreateCluster -> Text
$sel:nodeType:CreateCluster' :: CreateCluster -> Text
$sel:clusterName:CreateCluster' :: CreateCluster -> Text
$sel:parameterGroupName:CreateCluster' :: CreateCluster -> Maybe Text
$sel:port:CreateCluster' :: CreateCluster -> Maybe Int
$sel:tags:CreateCluster' :: CreateCluster -> Maybe [Tag]
$sel:numReplicasPerShard:CreateCluster' :: CreateCluster -> Maybe Int
$sel:description:CreateCluster' :: CreateCluster -> Maybe Text
$sel:snapshotName:CreateCluster' :: CreateCluster -> Maybe Text
$sel:snapshotRetentionLimit:CreateCluster' :: CreateCluster -> Maybe Int
$sel:kmsKeyId:CreateCluster' :: CreateCluster -> Maybe Text
$sel:maintenanceWindow:CreateCluster' :: CreateCluster -> Maybe Text
$sel:numShards:CreateCluster' :: CreateCluster -> Maybe Int
$sel:tLSEnabled:CreateCluster' :: CreateCluster -> Maybe Bool
$sel:subnetGroupName:CreateCluster' :: CreateCluster -> Maybe Text
$sel:snapshotWindow:CreateCluster' :: CreateCluster -> Maybe Text
$sel:snsTopicArn:CreateCluster' :: CreateCluster -> Maybe Text
$sel:autoMinorVersionUpgrade:CreateCluster' :: CreateCluster -> Maybe Bool
$sel:snapshotArns:CreateCluster' :: CreateCluster -> Maybe [Text]
$sel:securityGroupIds:CreateCluster' :: CreateCluster -> Maybe [Text]
$sel:engineVersion:CreateCluster' :: CreateCluster -> Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"EngineVersion" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
engineVersion,
            (Text
"SecurityGroupIds" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
securityGroupIds,
            (Text
"SnapshotArns" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
snapshotArns,
            (Text
"AutoMinorVersionUpgrade" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
autoMinorVersionUpgrade,
            (Text
"SnsTopicArn" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
snsTopicArn,
            (Text
"SnapshotWindow" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
snapshotWindow,
            (Text
"SubnetGroupName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
subnetGroupName,
            (Text
"TLSEnabled" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
tLSEnabled,
            (Text
"NumShards" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
numShards,
            (Text
"MaintenanceWindow" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
maintenanceWindow,
            (Text
"KmsKeyId" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
kmsKeyId,
            (Text
"SnapshotRetentionLimit" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
snapshotRetentionLimit,
            (Text
"SnapshotName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
snapshotName,
            (Text
"Description" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Text
"NumReplicasPerShard" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
numReplicasPerShard,
            (Text
"Tags" Text -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Tag] -> Pair) -> Maybe [Tag] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            (Text
"Port" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
port,
            (Text
"ParameterGroupName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
parameterGroupName,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"ClusterName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
clusterName),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"NodeType" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
nodeType),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"ACLName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
aCLName)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateClusterResponse' 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:
--
-- 'cluster', 'createClusterResponse_cluster' - The newly-created cluster.
--
-- 'httpStatus', 'createClusterResponse_httpStatus' - The response's http status code.
newCreateClusterResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateClusterResponse
newCreateClusterResponse :: Int -> CreateClusterResponse
newCreateClusterResponse Int
pHttpStatus_ =
  CreateClusterResponse' :: Maybe Cluster -> Int -> CreateClusterResponse
CreateClusterResponse'
    { $sel:cluster:CreateClusterResponse' :: Maybe Cluster
cluster = Maybe Cluster
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateClusterResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The newly-created cluster.
createClusterResponse_cluster :: Lens.Lens' CreateClusterResponse (Prelude.Maybe Cluster)
createClusterResponse_cluster :: (Maybe Cluster -> f (Maybe Cluster))
-> CreateClusterResponse -> f CreateClusterResponse
createClusterResponse_cluster = (CreateClusterResponse -> Maybe Cluster)
-> (CreateClusterResponse
    -> Maybe Cluster -> CreateClusterResponse)
-> Lens
     CreateClusterResponse
     CreateClusterResponse
     (Maybe Cluster)
     (Maybe Cluster)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateClusterResponse' {Maybe Cluster
cluster :: Maybe Cluster
$sel:cluster:CreateClusterResponse' :: CreateClusterResponse -> Maybe Cluster
cluster} -> Maybe Cluster
cluster) (\s :: CreateClusterResponse
s@CreateClusterResponse' {} Maybe Cluster
a -> CreateClusterResponse
s {$sel:cluster:CreateClusterResponse' :: Maybe Cluster
cluster = Maybe Cluster
a} :: CreateClusterResponse)

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

instance Prelude.NFData CreateClusterResponse