{-# 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.ElastiCache.ModifyReplicationGroupShardConfiguration
-- 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 a replication group\'s shards (node groups) by allowing you to
-- add shards, remove shards, or rebalance the keyspaces among existing
-- shards.
module Amazonka.ElastiCache.ModifyReplicationGroupShardConfiguration
  ( -- * Creating a Request
    ModifyReplicationGroupShardConfiguration (..),
    newModifyReplicationGroupShardConfiguration,

    -- * Request Lenses
    modifyReplicationGroupShardConfiguration_nodeGroupsToRemove,
    modifyReplicationGroupShardConfiguration_nodeGroupsToRetain,
    modifyReplicationGroupShardConfiguration_reshardingConfiguration,
    modifyReplicationGroupShardConfiguration_replicationGroupId,
    modifyReplicationGroupShardConfiguration_nodeGroupCount,
    modifyReplicationGroupShardConfiguration_applyImmediately,

    -- * Destructuring the Response
    ModifyReplicationGroupShardConfigurationResponse (..),
    newModifyReplicationGroupShardConfigurationResponse,

    -- * Response Lenses
    modifyReplicationGroupShardConfigurationResponse_replicationGroup,
    modifyReplicationGroupShardConfigurationResponse_httpStatus,
  )
where

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

-- | Represents the input for a @ModifyReplicationGroupShardConfiguration@
-- operation.
--
-- /See:/ 'newModifyReplicationGroupShardConfiguration' smart constructor.
data ModifyReplicationGroupShardConfiguration = ModifyReplicationGroupShardConfiguration'
  { -- | If the value of @NodeGroupCount@ is less than the current number of node
    -- groups (shards), then either @NodeGroupsToRemove@ or
    -- @NodeGroupsToRetain@ is required. @NodeGroupsToRemove@ is a list of
    -- @NodeGroupId@s to remove from the cluster.
    --
    -- ElastiCache for Redis will attempt to remove all node groups listed by
    -- @NodeGroupsToRemove@ from the cluster.
    ModifyReplicationGroupShardConfiguration -> Maybe [Text]
nodeGroupsToRemove :: Prelude.Maybe [Prelude.Text],
    -- | If the value of @NodeGroupCount@ is less than the current number of node
    -- groups (shards), then either @NodeGroupsToRemove@ or
    -- @NodeGroupsToRetain@ is required. @NodeGroupsToRetain@ is a list of
    -- @NodeGroupId@s to retain in the cluster.
    --
    -- ElastiCache for Redis will attempt to remove all node groups except
    -- those listed by @NodeGroupsToRetain@ from the cluster.
    ModifyReplicationGroupShardConfiguration -> Maybe [Text]
nodeGroupsToRetain :: Prelude.Maybe [Prelude.Text],
    -- | Specifies the preferred availability zones for each node group in the
    -- cluster. If the value of @NodeGroupCount@ is greater than the current
    -- number of node groups (shards), you can use this parameter to specify
    -- the preferred availability zones of the cluster\'s shards. If you omit
    -- this parameter ElastiCache selects availability zones for you.
    --
    -- You can specify this parameter only if the value of @NodeGroupCount@ is
    -- greater than the current number of node groups (shards).
    ModifyReplicationGroupShardConfiguration
-> Maybe [ReshardingConfiguration]
reshardingConfiguration :: Prelude.Maybe [ReshardingConfiguration],
    -- | The name of the Redis (cluster mode enabled) cluster (replication group)
    -- on which the shards are to be configured.
    ModifyReplicationGroupShardConfiguration -> Text
replicationGroupId :: Prelude.Text,
    -- | The number of node groups (shards) that results from the modification of
    -- the shard configuration.
    ModifyReplicationGroupShardConfiguration -> Int
nodeGroupCount :: Prelude.Int,
    -- | Indicates that the shard reconfiguration process begins immediately. At
    -- present, the only permitted value for this parameter is @true@.
    --
    -- Value: true
    ModifyReplicationGroupShardConfiguration -> Bool
applyImmediately :: Prelude.Bool
  }
  deriving (ModifyReplicationGroupShardConfiguration
-> ModifyReplicationGroupShardConfiguration -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifyReplicationGroupShardConfiguration
-> ModifyReplicationGroupShardConfiguration -> Bool
$c/= :: ModifyReplicationGroupShardConfiguration
-> ModifyReplicationGroupShardConfiguration -> Bool
== :: ModifyReplicationGroupShardConfiguration
-> ModifyReplicationGroupShardConfiguration -> Bool
$c== :: ModifyReplicationGroupShardConfiguration
-> ModifyReplicationGroupShardConfiguration -> Bool
Prelude.Eq, ReadPrec [ModifyReplicationGroupShardConfiguration]
ReadPrec ModifyReplicationGroupShardConfiguration
Int -> ReadS ModifyReplicationGroupShardConfiguration
ReadS [ModifyReplicationGroupShardConfiguration]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModifyReplicationGroupShardConfiguration]
$creadListPrec :: ReadPrec [ModifyReplicationGroupShardConfiguration]
readPrec :: ReadPrec ModifyReplicationGroupShardConfiguration
$creadPrec :: ReadPrec ModifyReplicationGroupShardConfiguration
readList :: ReadS [ModifyReplicationGroupShardConfiguration]
$creadList :: ReadS [ModifyReplicationGroupShardConfiguration]
readsPrec :: Int -> ReadS ModifyReplicationGroupShardConfiguration
$creadsPrec :: Int -> ReadS ModifyReplicationGroupShardConfiguration
Prelude.Read, Int -> ModifyReplicationGroupShardConfiguration -> ShowS
[ModifyReplicationGroupShardConfiguration] -> ShowS
ModifyReplicationGroupShardConfiguration -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifyReplicationGroupShardConfiguration] -> ShowS
$cshowList :: [ModifyReplicationGroupShardConfiguration] -> ShowS
show :: ModifyReplicationGroupShardConfiguration -> String
$cshow :: ModifyReplicationGroupShardConfiguration -> String
showsPrec :: Int -> ModifyReplicationGroupShardConfiguration -> ShowS
$cshowsPrec :: Int -> ModifyReplicationGroupShardConfiguration -> ShowS
Prelude.Show, forall x.
Rep ModifyReplicationGroupShardConfiguration x
-> ModifyReplicationGroupShardConfiguration
forall x.
ModifyReplicationGroupShardConfiguration
-> Rep ModifyReplicationGroupShardConfiguration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ModifyReplicationGroupShardConfiguration x
-> ModifyReplicationGroupShardConfiguration
$cfrom :: forall x.
ModifyReplicationGroupShardConfiguration
-> Rep ModifyReplicationGroupShardConfiguration x
Prelude.Generic)

-- |
-- Create a value of 'ModifyReplicationGroupShardConfiguration' 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:
--
-- 'nodeGroupsToRemove', 'modifyReplicationGroupShardConfiguration_nodeGroupsToRemove' - If the value of @NodeGroupCount@ is less than the current number of node
-- groups (shards), then either @NodeGroupsToRemove@ or
-- @NodeGroupsToRetain@ is required. @NodeGroupsToRemove@ is a list of
-- @NodeGroupId@s to remove from the cluster.
--
-- ElastiCache for Redis will attempt to remove all node groups listed by
-- @NodeGroupsToRemove@ from the cluster.
--
-- 'nodeGroupsToRetain', 'modifyReplicationGroupShardConfiguration_nodeGroupsToRetain' - If the value of @NodeGroupCount@ is less than the current number of node
-- groups (shards), then either @NodeGroupsToRemove@ or
-- @NodeGroupsToRetain@ is required. @NodeGroupsToRetain@ is a list of
-- @NodeGroupId@s to retain in the cluster.
--
-- ElastiCache for Redis will attempt to remove all node groups except
-- those listed by @NodeGroupsToRetain@ from the cluster.
--
-- 'reshardingConfiguration', 'modifyReplicationGroupShardConfiguration_reshardingConfiguration' - Specifies the preferred availability zones for each node group in the
-- cluster. If the value of @NodeGroupCount@ is greater than the current
-- number of node groups (shards), you can use this parameter to specify
-- the preferred availability zones of the cluster\'s shards. If you omit
-- this parameter ElastiCache selects availability zones for you.
--
-- You can specify this parameter only if the value of @NodeGroupCount@ is
-- greater than the current number of node groups (shards).
--
-- 'replicationGroupId', 'modifyReplicationGroupShardConfiguration_replicationGroupId' - The name of the Redis (cluster mode enabled) cluster (replication group)
-- on which the shards are to be configured.
--
-- 'nodeGroupCount', 'modifyReplicationGroupShardConfiguration_nodeGroupCount' - The number of node groups (shards) that results from the modification of
-- the shard configuration.
--
-- 'applyImmediately', 'modifyReplicationGroupShardConfiguration_applyImmediately' - Indicates that the shard reconfiguration process begins immediately. At
-- present, the only permitted value for this parameter is @true@.
--
-- Value: true
newModifyReplicationGroupShardConfiguration ::
  -- | 'replicationGroupId'
  Prelude.Text ->
  -- | 'nodeGroupCount'
  Prelude.Int ->
  -- | 'applyImmediately'
  Prelude.Bool ->
  ModifyReplicationGroupShardConfiguration
newModifyReplicationGroupShardConfiguration :: Text -> Int -> Bool -> ModifyReplicationGroupShardConfiguration
newModifyReplicationGroupShardConfiguration
  Text
pReplicationGroupId_
  Int
pNodeGroupCount_
  Bool
pApplyImmediately_ =
    ModifyReplicationGroupShardConfiguration'
      { $sel:nodeGroupsToRemove:ModifyReplicationGroupShardConfiguration' :: Maybe [Text]
nodeGroupsToRemove =
          forall a. Maybe a
Prelude.Nothing,
        $sel:nodeGroupsToRetain:ModifyReplicationGroupShardConfiguration' :: Maybe [Text]
nodeGroupsToRetain =
          forall a. Maybe a
Prelude.Nothing,
        $sel:reshardingConfiguration:ModifyReplicationGroupShardConfiguration' :: Maybe [ReshardingConfiguration]
reshardingConfiguration =
          forall a. Maybe a
Prelude.Nothing,
        $sel:replicationGroupId:ModifyReplicationGroupShardConfiguration' :: Text
replicationGroupId =
          Text
pReplicationGroupId_,
        $sel:nodeGroupCount:ModifyReplicationGroupShardConfiguration' :: Int
nodeGroupCount = Int
pNodeGroupCount_,
        $sel:applyImmediately:ModifyReplicationGroupShardConfiguration' :: Bool
applyImmediately =
          Bool
pApplyImmediately_
      }

-- | If the value of @NodeGroupCount@ is less than the current number of node
-- groups (shards), then either @NodeGroupsToRemove@ or
-- @NodeGroupsToRetain@ is required. @NodeGroupsToRemove@ is a list of
-- @NodeGroupId@s to remove from the cluster.
--
-- ElastiCache for Redis will attempt to remove all node groups listed by
-- @NodeGroupsToRemove@ from the cluster.
modifyReplicationGroupShardConfiguration_nodeGroupsToRemove :: Lens.Lens' ModifyReplicationGroupShardConfiguration (Prelude.Maybe [Prelude.Text])
modifyReplicationGroupShardConfiguration_nodeGroupsToRemove :: Lens' ModifyReplicationGroupShardConfiguration (Maybe [Text])
modifyReplicationGroupShardConfiguration_nodeGroupsToRemove = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfiguration' {Maybe [Text]
nodeGroupsToRemove :: Maybe [Text]
$sel:nodeGroupsToRemove:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
nodeGroupsToRemove} -> Maybe [Text]
nodeGroupsToRemove) (\s :: ModifyReplicationGroupShardConfiguration
s@ModifyReplicationGroupShardConfiguration' {} Maybe [Text]
a -> ModifyReplicationGroupShardConfiguration
s {$sel:nodeGroupsToRemove:ModifyReplicationGroupShardConfiguration' :: Maybe [Text]
nodeGroupsToRemove = Maybe [Text]
a} :: ModifyReplicationGroupShardConfiguration) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | If the value of @NodeGroupCount@ is less than the current number of node
-- groups (shards), then either @NodeGroupsToRemove@ or
-- @NodeGroupsToRetain@ is required. @NodeGroupsToRetain@ is a list of
-- @NodeGroupId@s to retain in the cluster.
--
-- ElastiCache for Redis will attempt to remove all node groups except
-- those listed by @NodeGroupsToRetain@ from the cluster.
modifyReplicationGroupShardConfiguration_nodeGroupsToRetain :: Lens.Lens' ModifyReplicationGroupShardConfiguration (Prelude.Maybe [Prelude.Text])
modifyReplicationGroupShardConfiguration_nodeGroupsToRetain :: Lens' ModifyReplicationGroupShardConfiguration (Maybe [Text])
modifyReplicationGroupShardConfiguration_nodeGroupsToRetain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfiguration' {Maybe [Text]
nodeGroupsToRetain :: Maybe [Text]
$sel:nodeGroupsToRetain:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
nodeGroupsToRetain} -> Maybe [Text]
nodeGroupsToRetain) (\s :: ModifyReplicationGroupShardConfiguration
s@ModifyReplicationGroupShardConfiguration' {} Maybe [Text]
a -> ModifyReplicationGroupShardConfiguration
s {$sel:nodeGroupsToRetain:ModifyReplicationGroupShardConfiguration' :: Maybe [Text]
nodeGroupsToRetain = Maybe [Text]
a} :: ModifyReplicationGroupShardConfiguration) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies the preferred availability zones for each node group in the
-- cluster. If the value of @NodeGroupCount@ is greater than the current
-- number of node groups (shards), you can use this parameter to specify
-- the preferred availability zones of the cluster\'s shards. If you omit
-- this parameter ElastiCache selects availability zones for you.
--
-- You can specify this parameter only if the value of @NodeGroupCount@ is
-- greater than the current number of node groups (shards).
modifyReplicationGroupShardConfiguration_reshardingConfiguration :: Lens.Lens' ModifyReplicationGroupShardConfiguration (Prelude.Maybe [ReshardingConfiguration])
modifyReplicationGroupShardConfiguration_reshardingConfiguration :: Lens'
  ModifyReplicationGroupShardConfiguration
  (Maybe [ReshardingConfiguration])
modifyReplicationGroupShardConfiguration_reshardingConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfiguration' {Maybe [ReshardingConfiguration]
reshardingConfiguration :: Maybe [ReshardingConfiguration]
$sel:reshardingConfiguration:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration
-> Maybe [ReshardingConfiguration]
reshardingConfiguration} -> Maybe [ReshardingConfiguration]
reshardingConfiguration) (\s :: ModifyReplicationGroupShardConfiguration
s@ModifyReplicationGroupShardConfiguration' {} Maybe [ReshardingConfiguration]
a -> ModifyReplicationGroupShardConfiguration
s {$sel:reshardingConfiguration:ModifyReplicationGroupShardConfiguration' :: Maybe [ReshardingConfiguration]
reshardingConfiguration = Maybe [ReshardingConfiguration]
a} :: ModifyReplicationGroupShardConfiguration) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the Redis (cluster mode enabled) cluster (replication group)
-- on which the shards are to be configured.
modifyReplicationGroupShardConfiguration_replicationGroupId :: Lens.Lens' ModifyReplicationGroupShardConfiguration Prelude.Text
modifyReplicationGroupShardConfiguration_replicationGroupId :: Lens' ModifyReplicationGroupShardConfiguration Text
modifyReplicationGroupShardConfiguration_replicationGroupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfiguration' {Text
replicationGroupId :: Text
$sel:replicationGroupId:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Text
replicationGroupId} -> Text
replicationGroupId) (\s :: ModifyReplicationGroupShardConfiguration
s@ModifyReplicationGroupShardConfiguration' {} Text
a -> ModifyReplicationGroupShardConfiguration
s {$sel:replicationGroupId:ModifyReplicationGroupShardConfiguration' :: Text
replicationGroupId = Text
a} :: ModifyReplicationGroupShardConfiguration)

-- | The number of node groups (shards) that results from the modification of
-- the shard configuration.
modifyReplicationGroupShardConfiguration_nodeGroupCount :: Lens.Lens' ModifyReplicationGroupShardConfiguration Prelude.Int
modifyReplicationGroupShardConfiguration_nodeGroupCount :: Lens' ModifyReplicationGroupShardConfiguration Int
modifyReplicationGroupShardConfiguration_nodeGroupCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfiguration' {Int
nodeGroupCount :: Int
$sel:nodeGroupCount:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Int
nodeGroupCount} -> Int
nodeGroupCount) (\s :: ModifyReplicationGroupShardConfiguration
s@ModifyReplicationGroupShardConfiguration' {} Int
a -> ModifyReplicationGroupShardConfiguration
s {$sel:nodeGroupCount:ModifyReplicationGroupShardConfiguration' :: Int
nodeGroupCount = Int
a} :: ModifyReplicationGroupShardConfiguration)

-- | Indicates that the shard reconfiguration process begins immediately. At
-- present, the only permitted value for this parameter is @true@.
--
-- Value: true
modifyReplicationGroupShardConfiguration_applyImmediately :: Lens.Lens' ModifyReplicationGroupShardConfiguration Prelude.Bool
modifyReplicationGroupShardConfiguration_applyImmediately :: Lens' ModifyReplicationGroupShardConfiguration Bool
modifyReplicationGroupShardConfiguration_applyImmediately = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfiguration' {Bool
applyImmediately :: Bool
$sel:applyImmediately:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Bool
applyImmediately} -> Bool
applyImmediately) (\s :: ModifyReplicationGroupShardConfiguration
s@ModifyReplicationGroupShardConfiguration' {} Bool
a -> ModifyReplicationGroupShardConfiguration
s {$sel:applyImmediately:ModifyReplicationGroupShardConfiguration' :: Bool
applyImmediately = Bool
a} :: ModifyReplicationGroupShardConfiguration)

instance
  Core.AWSRequest
    ModifyReplicationGroupShardConfiguration
  where
  type
    AWSResponse
      ModifyReplicationGroupShardConfiguration =
      ModifyReplicationGroupShardConfigurationResponse
  request :: (Service -> Service)
-> ModifyReplicationGroupShardConfiguration
-> Request ModifyReplicationGroupShardConfiguration
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 ModifyReplicationGroupShardConfiguration
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse
           (AWSResponse ModifyReplicationGroupShardConfiguration)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"ModifyReplicationGroupShardConfigurationResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe ReplicationGroup
-> Int -> ModifyReplicationGroupShardConfigurationResponse
ModifyReplicationGroupShardConfigurationResponse'
            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
"ReplicationGroup")
            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
    ModifyReplicationGroupShardConfiguration
  where
  hashWithSalt :: Int -> ModifyReplicationGroupShardConfiguration -> Int
hashWithSalt
    Int
_salt
    ModifyReplicationGroupShardConfiguration' {Bool
Int
Maybe [Text]
Maybe [ReshardingConfiguration]
Text
applyImmediately :: Bool
nodeGroupCount :: Int
replicationGroupId :: Text
reshardingConfiguration :: Maybe [ReshardingConfiguration]
nodeGroupsToRetain :: Maybe [Text]
nodeGroupsToRemove :: Maybe [Text]
$sel:applyImmediately:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Bool
$sel:nodeGroupCount:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Int
$sel:replicationGroupId:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Text
$sel:reshardingConfiguration:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration
-> Maybe [ReshardingConfiguration]
$sel:nodeGroupsToRetain:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
$sel:nodeGroupsToRemove:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
nodeGroupsToRemove
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
nodeGroupsToRetain
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ReshardingConfiguration]
reshardingConfiguration
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
replicationGroupId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Int
nodeGroupCount
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Bool
applyImmediately

instance
  Prelude.NFData
    ModifyReplicationGroupShardConfiguration
  where
  rnf :: ModifyReplicationGroupShardConfiguration -> ()
rnf ModifyReplicationGroupShardConfiguration' {Bool
Int
Maybe [Text]
Maybe [ReshardingConfiguration]
Text
applyImmediately :: Bool
nodeGroupCount :: Int
replicationGroupId :: Text
reshardingConfiguration :: Maybe [ReshardingConfiguration]
nodeGroupsToRetain :: Maybe [Text]
nodeGroupsToRemove :: Maybe [Text]
$sel:applyImmediately:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Bool
$sel:nodeGroupCount:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Int
$sel:replicationGroupId:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Text
$sel:reshardingConfiguration:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration
-> Maybe [ReshardingConfiguration]
$sel:nodeGroupsToRetain:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
$sel:nodeGroupsToRemove:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
nodeGroupsToRemove
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
nodeGroupsToRetain
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ReshardingConfiguration]
reshardingConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
replicationGroupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
nodeGroupCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Bool
applyImmediately

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

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

instance
  Data.ToQuery
    ModifyReplicationGroupShardConfiguration
  where
  toQuery :: ModifyReplicationGroupShardConfiguration -> QueryString
toQuery ModifyReplicationGroupShardConfiguration' {Bool
Int
Maybe [Text]
Maybe [ReshardingConfiguration]
Text
applyImmediately :: Bool
nodeGroupCount :: Int
replicationGroupId :: Text
reshardingConfiguration :: Maybe [ReshardingConfiguration]
nodeGroupsToRetain :: Maybe [Text]
nodeGroupsToRemove :: Maybe [Text]
$sel:applyImmediately:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Bool
$sel:nodeGroupCount:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Int
$sel:replicationGroupId:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Text
$sel:reshardingConfiguration:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration
-> Maybe [ReshardingConfiguration]
$sel:nodeGroupsToRetain:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
$sel:nodeGroupsToRemove:ModifyReplicationGroupShardConfiguration' :: ModifyReplicationGroupShardConfiguration -> Maybe [Text]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"ModifyReplicationGroupShardConfiguration" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2015-02-02" :: Prelude.ByteString),
        ByteString
"NodeGroupsToRemove"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"NodeGroupToRemove"
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
nodeGroupsToRemove
            ),
        ByteString
"NodeGroupsToRetain"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"NodeGroupToRetain"
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
nodeGroupsToRetain
            ),
        ByteString
"ReshardingConfiguration"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"ReshardingConfiguration"
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [ReshardingConfiguration]
reshardingConfiguration
            ),
        ByteString
"ReplicationGroupId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
replicationGroupId,
        ByteString
"NodeGroupCount" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Int
nodeGroupCount,
        ByteString
"ApplyImmediately" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Bool
applyImmediately
      ]

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

-- |
-- Create a value of 'ModifyReplicationGroupShardConfigurationResponse' 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:
--
-- 'replicationGroup', 'modifyReplicationGroupShardConfigurationResponse_replicationGroup' - Undocumented member.
--
-- 'httpStatus', 'modifyReplicationGroupShardConfigurationResponse_httpStatus' - The response's http status code.
newModifyReplicationGroupShardConfigurationResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ModifyReplicationGroupShardConfigurationResponse
newModifyReplicationGroupShardConfigurationResponse :: Int -> ModifyReplicationGroupShardConfigurationResponse
newModifyReplicationGroupShardConfigurationResponse
  Int
pHttpStatus_ =
    ModifyReplicationGroupShardConfigurationResponse'
      { $sel:replicationGroup:ModifyReplicationGroupShardConfigurationResponse' :: Maybe ReplicationGroup
replicationGroup =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:ModifyReplicationGroupShardConfigurationResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Undocumented member.
modifyReplicationGroupShardConfigurationResponse_replicationGroup :: Lens.Lens' ModifyReplicationGroupShardConfigurationResponse (Prelude.Maybe ReplicationGroup)
modifyReplicationGroupShardConfigurationResponse_replicationGroup :: Lens'
  ModifyReplicationGroupShardConfigurationResponse
  (Maybe ReplicationGroup)
modifyReplicationGroupShardConfigurationResponse_replicationGroup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyReplicationGroupShardConfigurationResponse' {Maybe ReplicationGroup
replicationGroup :: Maybe ReplicationGroup
$sel:replicationGroup:ModifyReplicationGroupShardConfigurationResponse' :: ModifyReplicationGroupShardConfigurationResponse
-> Maybe ReplicationGroup
replicationGroup} -> Maybe ReplicationGroup
replicationGroup) (\s :: ModifyReplicationGroupShardConfigurationResponse
s@ModifyReplicationGroupShardConfigurationResponse' {} Maybe ReplicationGroup
a -> ModifyReplicationGroupShardConfigurationResponse
s {$sel:replicationGroup:ModifyReplicationGroupShardConfigurationResponse' :: Maybe ReplicationGroup
replicationGroup = Maybe ReplicationGroup
a} :: ModifyReplicationGroupShardConfigurationResponse)

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

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