{-# 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.Redshift.ResizeCluster
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Changes the size of the cluster. You can change the cluster\'s type, or
-- change the number or type of nodes. The default behavior is to use the
-- elastic resize method. With an elastic resize, your cluster is available
-- for read and write operations more quickly than with the classic resize
-- method.
--
-- Elastic resize operations have the following restrictions:
--
-- -   You can only resize clusters of the following types:
--
--     -   dc1.large (if your cluster is in a VPC)
--
--     -   dc1.8xlarge (if your cluster is in a VPC)
--
--     -   dc2.large
--
--     -   dc2.8xlarge
--
--     -   ds2.xlarge
--
--     -   ds2.8xlarge
--
--     -   ra3.xlplus
--
--     -   ra3.4xlarge
--
--     -   ra3.16xlarge
--
-- -   The type of nodes that you add must match the node type for the
--     cluster.
module Amazonka.Redshift.ResizeCluster
  ( -- * Creating a Request
    ResizeCluster (..),
    newResizeCluster,

    -- * Request Lenses
    resizeCluster_classic,
    resizeCluster_clusterType,
    resizeCluster_nodeType,
    resizeCluster_numberOfNodes,
    resizeCluster_reservedNodeId,
    resizeCluster_targetReservedNodeOfferingId,
    resizeCluster_clusterIdentifier,

    -- * Destructuring the Response
    ResizeClusterResponse (..),
    newResizeClusterResponse,

    -- * Response Lenses
    resizeClusterResponse_cluster,
    resizeClusterResponse_httpStatus,
  )
where

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 Amazonka.Redshift.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Describes a resize cluster operation. For example, a scheduled action to
-- run the @ResizeCluster@ API operation.
--
-- /See:/ 'newResizeCluster' smart constructor.
data ResizeCluster = ResizeCluster'
  { -- | A boolean value indicating whether the resize operation is using the
    -- classic resize process. If you don\'t provide this parameter or set the
    -- value to @false@, the resize type is elastic.
    ResizeCluster -> Maybe Bool
classic :: Prelude.Maybe Prelude.Bool,
    -- | The new cluster type for the specified cluster.
    ResizeCluster -> Maybe Text
clusterType :: Prelude.Maybe Prelude.Text,
    -- | The new node type for the nodes you are adding. If not specified, the
    -- cluster\'s current node type is used.
    ResizeCluster -> Maybe Text
nodeType :: Prelude.Maybe Prelude.Text,
    -- | The new number of nodes for the cluster. If not specified, the
    -- cluster\'s current number of nodes is used.
    ResizeCluster -> Maybe Int
numberOfNodes :: Prelude.Maybe Prelude.Int,
    -- | The identifier of the reserved node.
    ResizeCluster -> Maybe Text
reservedNodeId :: Prelude.Maybe Prelude.Text,
    -- | The identifier of the target reserved node offering.
    ResizeCluster -> Maybe Text
targetReservedNodeOfferingId :: Prelude.Maybe Prelude.Text,
    -- | The unique identifier for the cluster to resize.
    ResizeCluster -> Text
clusterIdentifier :: Prelude.Text
  }
  deriving (ResizeCluster -> ResizeCluster -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResizeCluster -> ResizeCluster -> Bool
$c/= :: ResizeCluster -> ResizeCluster -> Bool
== :: ResizeCluster -> ResizeCluster -> Bool
$c== :: ResizeCluster -> ResizeCluster -> Bool
Prelude.Eq, ReadPrec [ResizeCluster]
ReadPrec ResizeCluster
Int -> ReadS ResizeCluster
ReadS [ResizeCluster]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ResizeCluster]
$creadListPrec :: ReadPrec [ResizeCluster]
readPrec :: ReadPrec ResizeCluster
$creadPrec :: ReadPrec ResizeCluster
readList :: ReadS [ResizeCluster]
$creadList :: ReadS [ResizeCluster]
readsPrec :: Int -> ReadS ResizeCluster
$creadsPrec :: Int -> ReadS ResizeCluster
Prelude.Read, Int -> ResizeCluster -> ShowS
[ResizeCluster] -> ShowS
ResizeCluster -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResizeCluster] -> ShowS
$cshowList :: [ResizeCluster] -> ShowS
show :: ResizeCluster -> String
$cshow :: ResizeCluster -> String
showsPrec :: Int -> ResizeCluster -> ShowS
$cshowsPrec :: Int -> ResizeCluster -> ShowS
Prelude.Show, forall x. Rep ResizeCluster x -> ResizeCluster
forall x. ResizeCluster -> Rep ResizeCluster x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ResizeCluster x -> ResizeCluster
$cfrom :: forall x. ResizeCluster -> Rep ResizeCluster x
Prelude.Generic)

-- |
-- Create a value of 'ResizeCluster' 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:
--
-- 'classic', 'resizeCluster_classic' - A boolean value indicating whether the resize operation is using the
-- classic resize process. If you don\'t provide this parameter or set the
-- value to @false@, the resize type is elastic.
--
-- 'clusterType', 'resizeCluster_clusterType' - The new cluster type for the specified cluster.
--
-- 'nodeType', 'resizeCluster_nodeType' - The new node type for the nodes you are adding. If not specified, the
-- cluster\'s current node type is used.
--
-- 'numberOfNodes', 'resizeCluster_numberOfNodes' - The new number of nodes for the cluster. If not specified, the
-- cluster\'s current number of nodes is used.
--
-- 'reservedNodeId', 'resizeCluster_reservedNodeId' - The identifier of the reserved node.
--
-- 'targetReservedNodeOfferingId', 'resizeCluster_targetReservedNodeOfferingId' - The identifier of the target reserved node offering.
--
-- 'clusterIdentifier', 'resizeCluster_clusterIdentifier' - The unique identifier for the cluster to resize.
newResizeCluster ::
  -- | 'clusterIdentifier'
  Prelude.Text ->
  ResizeCluster
newResizeCluster :: Text -> ResizeCluster
newResizeCluster Text
pClusterIdentifier_ =
  ResizeCluster'
    { $sel:classic:ResizeCluster' :: Maybe Bool
classic = forall a. Maybe a
Prelude.Nothing,
      $sel:clusterType:ResizeCluster' :: Maybe Text
clusterType = forall a. Maybe a
Prelude.Nothing,
      $sel:nodeType:ResizeCluster' :: Maybe Text
nodeType = forall a. Maybe a
Prelude.Nothing,
      $sel:numberOfNodes:ResizeCluster' :: Maybe Int
numberOfNodes = forall a. Maybe a
Prelude.Nothing,
      $sel:reservedNodeId:ResizeCluster' :: Maybe Text
reservedNodeId = forall a. Maybe a
Prelude.Nothing,
      $sel:targetReservedNodeOfferingId:ResizeCluster' :: Maybe Text
targetReservedNodeOfferingId = forall a. Maybe a
Prelude.Nothing,
      $sel:clusterIdentifier:ResizeCluster' :: Text
clusterIdentifier = Text
pClusterIdentifier_
    }

-- | A boolean value indicating whether the resize operation is using the
-- classic resize process. If you don\'t provide this parameter or set the
-- value to @false@, the resize type is elastic.
resizeCluster_classic :: Lens.Lens' ResizeCluster (Prelude.Maybe Prelude.Bool)
resizeCluster_classic :: Lens' ResizeCluster (Maybe Bool)
resizeCluster_classic = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Maybe Bool
classic :: Maybe Bool
$sel:classic:ResizeCluster' :: ResizeCluster -> Maybe Bool
classic} -> Maybe Bool
classic) (\s :: ResizeCluster
s@ResizeCluster' {} Maybe Bool
a -> ResizeCluster
s {$sel:classic:ResizeCluster' :: Maybe Bool
classic = Maybe Bool
a} :: ResizeCluster)

-- | The new cluster type for the specified cluster.
resizeCluster_clusterType :: Lens.Lens' ResizeCluster (Prelude.Maybe Prelude.Text)
resizeCluster_clusterType :: Lens' ResizeCluster (Maybe Text)
resizeCluster_clusterType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Maybe Text
clusterType :: Maybe Text
$sel:clusterType:ResizeCluster' :: ResizeCluster -> Maybe Text
clusterType} -> Maybe Text
clusterType) (\s :: ResizeCluster
s@ResizeCluster' {} Maybe Text
a -> ResizeCluster
s {$sel:clusterType:ResizeCluster' :: Maybe Text
clusterType = Maybe Text
a} :: ResizeCluster)

-- | The new node type for the nodes you are adding. If not specified, the
-- cluster\'s current node type is used.
resizeCluster_nodeType :: Lens.Lens' ResizeCluster (Prelude.Maybe Prelude.Text)
resizeCluster_nodeType :: Lens' ResizeCluster (Maybe Text)
resizeCluster_nodeType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Maybe Text
nodeType :: Maybe Text
$sel:nodeType:ResizeCluster' :: ResizeCluster -> Maybe Text
nodeType} -> Maybe Text
nodeType) (\s :: ResizeCluster
s@ResizeCluster' {} Maybe Text
a -> ResizeCluster
s {$sel:nodeType:ResizeCluster' :: Maybe Text
nodeType = Maybe Text
a} :: ResizeCluster)

-- | The new number of nodes for the cluster. If not specified, the
-- cluster\'s current number of nodes is used.
resizeCluster_numberOfNodes :: Lens.Lens' ResizeCluster (Prelude.Maybe Prelude.Int)
resizeCluster_numberOfNodes :: Lens' ResizeCluster (Maybe Int)
resizeCluster_numberOfNodes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Maybe Int
numberOfNodes :: Maybe Int
$sel:numberOfNodes:ResizeCluster' :: ResizeCluster -> Maybe Int
numberOfNodes} -> Maybe Int
numberOfNodes) (\s :: ResizeCluster
s@ResizeCluster' {} Maybe Int
a -> ResizeCluster
s {$sel:numberOfNodes:ResizeCluster' :: Maybe Int
numberOfNodes = Maybe Int
a} :: ResizeCluster)

-- | The identifier of the reserved node.
resizeCluster_reservedNodeId :: Lens.Lens' ResizeCluster (Prelude.Maybe Prelude.Text)
resizeCluster_reservedNodeId :: Lens' ResizeCluster (Maybe Text)
resizeCluster_reservedNodeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Maybe Text
reservedNodeId :: Maybe Text
$sel:reservedNodeId:ResizeCluster' :: ResizeCluster -> Maybe Text
reservedNodeId} -> Maybe Text
reservedNodeId) (\s :: ResizeCluster
s@ResizeCluster' {} Maybe Text
a -> ResizeCluster
s {$sel:reservedNodeId:ResizeCluster' :: Maybe Text
reservedNodeId = Maybe Text
a} :: ResizeCluster)

-- | The identifier of the target reserved node offering.
resizeCluster_targetReservedNodeOfferingId :: Lens.Lens' ResizeCluster (Prelude.Maybe Prelude.Text)
resizeCluster_targetReservedNodeOfferingId :: Lens' ResizeCluster (Maybe Text)
resizeCluster_targetReservedNodeOfferingId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Maybe Text
targetReservedNodeOfferingId :: Maybe Text
$sel:targetReservedNodeOfferingId:ResizeCluster' :: ResizeCluster -> Maybe Text
targetReservedNodeOfferingId} -> Maybe Text
targetReservedNodeOfferingId) (\s :: ResizeCluster
s@ResizeCluster' {} Maybe Text
a -> ResizeCluster
s {$sel:targetReservedNodeOfferingId:ResizeCluster' :: Maybe Text
targetReservedNodeOfferingId = Maybe Text
a} :: ResizeCluster)

-- | The unique identifier for the cluster to resize.
resizeCluster_clusterIdentifier :: Lens.Lens' ResizeCluster Prelude.Text
resizeCluster_clusterIdentifier :: Lens' ResizeCluster Text
resizeCluster_clusterIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeCluster' {Text
clusterIdentifier :: Text
$sel:clusterIdentifier:ResizeCluster' :: ResizeCluster -> Text
clusterIdentifier} -> Text
clusterIdentifier) (\s :: ResizeCluster
s@ResizeCluster' {} Text
a -> ResizeCluster
s {$sel:clusterIdentifier:ResizeCluster' :: Text
clusterIdentifier = Text
a} :: ResizeCluster)

instance Core.AWSRequest ResizeCluster where
  type
    AWSResponse ResizeCluster =
      ResizeClusterResponse
  request :: (Service -> Service) -> ResizeCluster -> Request ResizeCluster
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 ResizeCluster
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ResizeCluster)))
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
"ResizeClusterResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe Cluster -> Int -> ResizeClusterResponse
ResizeClusterResponse'
            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
"Cluster")
            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 ResizeCluster where
  hashWithSalt :: Int -> ResizeCluster -> Int
hashWithSalt Int
_salt ResizeCluster' {Maybe Bool
Maybe Int
Maybe Text
Text
clusterIdentifier :: Text
targetReservedNodeOfferingId :: Maybe Text
reservedNodeId :: Maybe Text
numberOfNodes :: Maybe Int
nodeType :: Maybe Text
clusterType :: Maybe Text
classic :: Maybe Bool
$sel:clusterIdentifier:ResizeCluster' :: ResizeCluster -> Text
$sel:targetReservedNodeOfferingId:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:reservedNodeId:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:numberOfNodes:ResizeCluster' :: ResizeCluster -> Maybe Int
$sel:nodeType:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:clusterType:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:classic:ResizeCluster' :: ResizeCluster -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
classic
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clusterType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nodeType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
numberOfNodes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
reservedNodeId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
targetReservedNodeOfferingId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
clusterIdentifier

instance Prelude.NFData ResizeCluster where
  rnf :: ResizeCluster -> ()
rnf ResizeCluster' {Maybe Bool
Maybe Int
Maybe Text
Text
clusterIdentifier :: Text
targetReservedNodeOfferingId :: Maybe Text
reservedNodeId :: Maybe Text
numberOfNodes :: Maybe Int
nodeType :: Maybe Text
clusterType :: Maybe Text
classic :: Maybe Bool
$sel:clusterIdentifier:ResizeCluster' :: ResizeCluster -> Text
$sel:targetReservedNodeOfferingId:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:reservedNodeId:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:numberOfNodes:ResizeCluster' :: ResizeCluster -> Maybe Int
$sel:nodeType:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:clusterType:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:classic:ResizeCluster' :: ResizeCluster -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
classic
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clusterType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nodeType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
numberOfNodes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
reservedNodeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
targetReservedNodeOfferingId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
clusterIdentifier

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

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

instance Data.ToQuery ResizeCluster where
  toQuery :: ResizeCluster -> QueryString
toQuery ResizeCluster' {Maybe Bool
Maybe Int
Maybe Text
Text
clusterIdentifier :: Text
targetReservedNodeOfferingId :: Maybe Text
reservedNodeId :: Maybe Text
numberOfNodes :: Maybe Int
nodeType :: Maybe Text
clusterType :: Maybe Text
classic :: Maybe Bool
$sel:clusterIdentifier:ResizeCluster' :: ResizeCluster -> Text
$sel:targetReservedNodeOfferingId:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:reservedNodeId:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:numberOfNodes:ResizeCluster' :: ResizeCluster -> Maybe Int
$sel:nodeType:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:clusterType:ResizeCluster' :: ResizeCluster -> Maybe Text
$sel:classic:ResizeCluster' :: ResizeCluster -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ResizeCluster" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2012-12-01" :: Prelude.ByteString),
        ByteString
"Classic" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
classic,
        ByteString
"ClusterType" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
clusterType,
        ByteString
"NodeType" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nodeType,
        ByteString
"NumberOfNodes" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
numberOfNodes,
        ByteString
"ReservedNodeId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
reservedNodeId,
        ByteString
"TargetReservedNodeOfferingId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
targetReservedNodeOfferingId,
        ByteString
"ClusterIdentifier" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
clusterIdentifier
      ]

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

-- |
-- Create a value of 'ResizeClusterResponse' 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', 'resizeClusterResponse_cluster' - Undocumented member.
--
-- 'httpStatus', 'resizeClusterResponse_httpStatus' - The response's http status code.
newResizeClusterResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ResizeClusterResponse
newResizeClusterResponse :: Int -> ResizeClusterResponse
newResizeClusterResponse Int
pHttpStatus_ =
  ResizeClusterResponse'
    { $sel:cluster:ResizeClusterResponse' :: Maybe Cluster
cluster = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ResizeClusterResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
resizeClusterResponse_cluster :: Lens.Lens' ResizeClusterResponse (Prelude.Maybe Cluster)
resizeClusterResponse_cluster :: Lens' ResizeClusterResponse (Maybe Cluster)
resizeClusterResponse_cluster = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResizeClusterResponse' {Maybe Cluster
cluster :: Maybe Cluster
$sel:cluster:ResizeClusterResponse' :: ResizeClusterResponse -> Maybe Cluster
cluster} -> Maybe Cluster
cluster) (\s :: ResizeClusterResponse
s@ResizeClusterResponse' {} Maybe Cluster
a -> ResizeClusterResponse
s {$sel:cluster:ResizeClusterResponse' :: Maybe Cluster
cluster = Maybe Cluster
a} :: ResizeClusterResponse)

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

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