{-# 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.DescribeClusters
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns information about all provisioned clusters if no cluster
-- identifier is specified, or about a specific cluster if a cluster name
-- is supplied.
--
-- This operation returns paginated results.
module Amazonka.MemoryDb.DescribeClusters
  ( -- * Creating a Request
    DescribeClusters (..),
    newDescribeClusters,

    -- * Request Lenses
    describeClusters_clusterName,
    describeClusters_maxResults,
    describeClusters_nextToken,
    describeClusters_showShardDetails,

    -- * Destructuring the Response
    DescribeClustersResponse (..),
    newDescribeClustersResponse,

    -- * Response Lenses
    describeClustersResponse_clusters,
    describeClustersResponse_nextToken,
    describeClustersResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDescribeClusters' smart constructor.
data DescribeClusters = DescribeClusters'
  { -- | The name of the cluster
    DescribeClusters -> Maybe Text
clusterName :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of records to include in the response. If more
    -- records exist than the specified MaxResults value, a token is included
    -- in the response so that the remaining results can be retrieved.
    DescribeClusters -> Maybe Int
maxResults :: Prelude.Maybe Prelude.Int,
    -- | An optional argument to pass in case the total number of records exceeds
    -- the value of MaxResults. If nextToken is returned, there are more
    -- results available. The value of nextToken is a unique pagination token
    -- for each page. Make the call again using the returned token to retrieve
    -- the next page. Keep all other arguments unchanged.
    DescribeClusters -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An optional flag that can be included in the request to retrieve
    -- information about the individual shard(s).
    DescribeClusters -> Maybe Bool
showShardDetails :: Prelude.Maybe Prelude.Bool
  }
  deriving (DescribeClusters -> DescribeClusters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeClusters -> DescribeClusters -> Bool
$c/= :: DescribeClusters -> DescribeClusters -> Bool
== :: DescribeClusters -> DescribeClusters -> Bool
$c== :: DescribeClusters -> DescribeClusters -> Bool
Prelude.Eq, ReadPrec [DescribeClusters]
ReadPrec DescribeClusters
Int -> ReadS DescribeClusters
ReadS [DescribeClusters]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeClusters]
$creadListPrec :: ReadPrec [DescribeClusters]
readPrec :: ReadPrec DescribeClusters
$creadPrec :: ReadPrec DescribeClusters
readList :: ReadS [DescribeClusters]
$creadList :: ReadS [DescribeClusters]
readsPrec :: Int -> ReadS DescribeClusters
$creadsPrec :: Int -> ReadS DescribeClusters
Prelude.Read, Int -> DescribeClusters -> ShowS
[DescribeClusters] -> ShowS
DescribeClusters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeClusters] -> ShowS
$cshowList :: [DescribeClusters] -> ShowS
show :: DescribeClusters -> String
$cshow :: DescribeClusters -> String
showsPrec :: Int -> DescribeClusters -> ShowS
$cshowsPrec :: Int -> DescribeClusters -> ShowS
Prelude.Show, forall x. Rep DescribeClusters x -> DescribeClusters
forall x. DescribeClusters -> Rep DescribeClusters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeClusters x -> DescribeClusters
$cfrom :: forall x. DescribeClusters -> Rep DescribeClusters x
Prelude.Generic)

-- |
-- Create a value of 'DescribeClusters' 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:
--
-- 'clusterName', 'describeClusters_clusterName' - The name of the cluster
--
-- 'maxResults', 'describeClusters_maxResults' - The maximum number of records to include in the response. If more
-- records exist than the specified MaxResults value, a token is included
-- in the response so that the remaining results can be retrieved.
--
-- 'nextToken', 'describeClusters_nextToken' - An optional argument to pass in case the total number of records exceeds
-- the value of MaxResults. If nextToken is returned, there are more
-- results available. The value of nextToken is a unique pagination token
-- for each page. Make the call again using the returned token to retrieve
-- the next page. Keep all other arguments unchanged.
--
-- 'showShardDetails', 'describeClusters_showShardDetails' - An optional flag that can be included in the request to retrieve
-- information about the individual shard(s).
newDescribeClusters ::
  DescribeClusters
newDescribeClusters :: DescribeClusters
newDescribeClusters =
  DescribeClusters'
    { $sel:clusterName:DescribeClusters' :: Maybe Text
clusterName = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:DescribeClusters' :: Maybe Int
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeClusters' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:showShardDetails:DescribeClusters' :: Maybe Bool
showShardDetails = forall a. Maybe a
Prelude.Nothing
    }

-- | The name of the cluster
describeClusters_clusterName :: Lens.Lens' DescribeClusters (Prelude.Maybe Prelude.Text)
describeClusters_clusterName :: Lens' DescribeClusters (Maybe Text)
describeClusters_clusterName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClusters' {Maybe Text
clusterName :: Maybe Text
$sel:clusterName:DescribeClusters' :: DescribeClusters -> Maybe Text
clusterName} -> Maybe Text
clusterName) (\s :: DescribeClusters
s@DescribeClusters' {} Maybe Text
a -> DescribeClusters
s {$sel:clusterName:DescribeClusters' :: Maybe Text
clusterName = Maybe Text
a} :: DescribeClusters)

-- | The maximum number of records to include in the response. If more
-- records exist than the specified MaxResults value, a token is included
-- in the response so that the remaining results can be retrieved.
describeClusters_maxResults :: Lens.Lens' DescribeClusters (Prelude.Maybe Prelude.Int)
describeClusters_maxResults :: Lens' DescribeClusters (Maybe Int)
describeClusters_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClusters' {Maybe Int
maxResults :: Maybe Int
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Int
maxResults} -> Maybe Int
maxResults) (\s :: DescribeClusters
s@DescribeClusters' {} Maybe Int
a -> DescribeClusters
s {$sel:maxResults:DescribeClusters' :: Maybe Int
maxResults = Maybe Int
a} :: DescribeClusters)

-- | An optional argument to pass in case the total number of records exceeds
-- the value of MaxResults. If nextToken is returned, there are more
-- results available. The value of nextToken is a unique pagination token
-- for each page. Make the call again using the returned token to retrieve
-- the next page. Keep all other arguments unchanged.
describeClusters_nextToken :: Lens.Lens' DescribeClusters (Prelude.Maybe Prelude.Text)
describeClusters_nextToken :: Lens' DescribeClusters (Maybe Text)
describeClusters_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClusters' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeClusters
s@DescribeClusters' {} Maybe Text
a -> DescribeClusters
s {$sel:nextToken:DescribeClusters' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeClusters)

-- | An optional flag that can be included in the request to retrieve
-- information about the individual shard(s).
describeClusters_showShardDetails :: Lens.Lens' DescribeClusters (Prelude.Maybe Prelude.Bool)
describeClusters_showShardDetails :: Lens' DescribeClusters (Maybe Bool)
describeClusters_showShardDetails = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClusters' {Maybe Bool
showShardDetails :: Maybe Bool
$sel:showShardDetails:DescribeClusters' :: DescribeClusters -> Maybe Bool
showShardDetails} -> Maybe Bool
showShardDetails) (\s :: DescribeClusters
s@DescribeClusters' {} Maybe Bool
a -> DescribeClusters
s {$sel:showShardDetails:DescribeClusters' :: Maybe Bool
showShardDetails = Maybe Bool
a} :: DescribeClusters)

instance Core.AWSPager DescribeClusters where
  page :: DescribeClusters
-> AWSResponse DescribeClusters -> Maybe DescribeClusters
page DescribeClusters
rq AWSResponse DescribeClusters
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeClusters
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeClustersResponse (Maybe Text)
describeClustersResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeClusters
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeClustersResponse (Maybe [Cluster])
describeClustersResponse_clusters
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ DescribeClusters
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' DescribeClusters (Maybe Text)
describeClusters_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse DescribeClusters
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeClustersResponse (Maybe Text)
describeClustersResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest DescribeClusters where
  type
    AWSResponse DescribeClusters =
      DescribeClustersResponse
  request :: (Service -> Service)
-> DescribeClusters -> Request DescribeClusters
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DescribeClusters
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DescribeClusters)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [Cluster] -> Maybe Text -> Int -> DescribeClustersResponse
DescribeClustersResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Clusters" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"NextToken")
            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 DescribeClusters where
  hashWithSalt :: Int -> DescribeClusters -> Int
hashWithSalt Int
_salt DescribeClusters' {Maybe Bool
Maybe Int
Maybe Text
showShardDetails :: Maybe Bool
nextToken :: Maybe Text
maxResults :: Maybe Int
clusterName :: Maybe Text
$sel:showShardDetails:DescribeClusters' :: DescribeClusters -> Maybe Bool
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Int
$sel:clusterName:DescribeClusters' :: DescribeClusters -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clusterName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
showShardDetails

instance Prelude.NFData DescribeClusters where
  rnf :: DescribeClusters -> ()
rnf DescribeClusters' {Maybe Bool
Maybe Int
Maybe Text
showShardDetails :: Maybe Bool
nextToken :: Maybe Text
maxResults :: Maybe Int
clusterName :: Maybe Text
$sel:showShardDetails:DescribeClusters' :: DescribeClusters -> Maybe Bool
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Int
$sel:clusterName:DescribeClusters' :: DescribeClusters -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clusterName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
showShardDetails

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

instance Data.ToJSON DescribeClusters where
  toJSON :: DescribeClusters -> Value
toJSON DescribeClusters' {Maybe Bool
Maybe Int
Maybe Text
showShardDetails :: Maybe Bool
nextToken :: Maybe Text
maxResults :: Maybe Int
clusterName :: Maybe Text
$sel:showShardDetails:DescribeClusters' :: DescribeClusters -> Maybe Bool
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Int
$sel:clusterName:DescribeClusters' :: DescribeClusters -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClusterName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clusterName,
            (Key
"MaxResults" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
maxResults,
            (Key
"NextToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken,
            (Key
"ShowShardDetails" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
showShardDetails
          ]
      )

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

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

-- | /See:/ 'newDescribeClustersResponse' smart constructor.
data DescribeClustersResponse = DescribeClustersResponse'
  { -- | A list of clusters
    DescribeClustersResponse -> Maybe [Cluster]
clusters :: Prelude.Maybe [Cluster],
    -- | An optional argument to pass in case the total number of records exceeds
    -- the value of MaxResults. If nextToken is returned, there are more
    -- results available. The value of nextToken is a unique pagination token
    -- for each page. Make the call again using the returned token to retrieve
    -- the next page. Keep all other arguments unchanged.
    DescribeClustersResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    DescribeClustersResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeClustersResponse -> DescribeClustersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeClustersResponse -> DescribeClustersResponse -> Bool
$c/= :: DescribeClustersResponse -> DescribeClustersResponse -> Bool
== :: DescribeClustersResponse -> DescribeClustersResponse -> Bool
$c== :: DescribeClustersResponse -> DescribeClustersResponse -> Bool
Prelude.Eq, ReadPrec [DescribeClustersResponse]
ReadPrec DescribeClustersResponse
Int -> ReadS DescribeClustersResponse
ReadS [DescribeClustersResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeClustersResponse]
$creadListPrec :: ReadPrec [DescribeClustersResponse]
readPrec :: ReadPrec DescribeClustersResponse
$creadPrec :: ReadPrec DescribeClustersResponse
readList :: ReadS [DescribeClustersResponse]
$creadList :: ReadS [DescribeClustersResponse]
readsPrec :: Int -> ReadS DescribeClustersResponse
$creadsPrec :: Int -> ReadS DescribeClustersResponse
Prelude.Read, Int -> DescribeClustersResponse -> ShowS
[DescribeClustersResponse] -> ShowS
DescribeClustersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeClustersResponse] -> ShowS
$cshowList :: [DescribeClustersResponse] -> ShowS
show :: DescribeClustersResponse -> String
$cshow :: DescribeClustersResponse -> String
showsPrec :: Int -> DescribeClustersResponse -> ShowS
$cshowsPrec :: Int -> DescribeClustersResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeClustersResponse x -> DescribeClustersResponse
forall x.
DescribeClustersResponse -> Rep DescribeClustersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeClustersResponse x -> DescribeClustersResponse
$cfrom :: forall x.
DescribeClustersResponse -> Rep DescribeClustersResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeClustersResponse' 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:
--
-- 'clusters', 'describeClustersResponse_clusters' - A list of clusters
--
-- 'nextToken', 'describeClustersResponse_nextToken' - An optional argument to pass in case the total number of records exceeds
-- the value of MaxResults. If nextToken is returned, there are more
-- results available. The value of nextToken is a unique pagination token
-- for each page. Make the call again using the returned token to retrieve
-- the next page. Keep all other arguments unchanged.
--
-- 'httpStatus', 'describeClustersResponse_httpStatus' - The response's http status code.
newDescribeClustersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeClustersResponse
newDescribeClustersResponse :: Int -> DescribeClustersResponse
newDescribeClustersResponse Int
pHttpStatus_ =
  DescribeClustersResponse'
    { $sel:clusters:DescribeClustersResponse' :: Maybe [Cluster]
clusters =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeClustersResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeClustersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of clusters
describeClustersResponse_clusters :: Lens.Lens' DescribeClustersResponse (Prelude.Maybe [Cluster])
describeClustersResponse_clusters :: Lens' DescribeClustersResponse (Maybe [Cluster])
describeClustersResponse_clusters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClustersResponse' {Maybe [Cluster]
clusters :: Maybe [Cluster]
$sel:clusters:DescribeClustersResponse' :: DescribeClustersResponse -> Maybe [Cluster]
clusters} -> Maybe [Cluster]
clusters) (\s :: DescribeClustersResponse
s@DescribeClustersResponse' {} Maybe [Cluster]
a -> DescribeClustersResponse
s {$sel:clusters:DescribeClustersResponse' :: Maybe [Cluster]
clusters = Maybe [Cluster]
a} :: DescribeClustersResponse) 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

-- | An optional argument to pass in case the total number of records exceeds
-- the value of MaxResults. If nextToken is returned, there are more
-- results available. The value of nextToken is a unique pagination token
-- for each page. Make the call again using the returned token to retrieve
-- the next page. Keep all other arguments unchanged.
describeClustersResponse_nextToken :: Lens.Lens' DescribeClustersResponse (Prelude.Maybe Prelude.Text)
describeClustersResponse_nextToken :: Lens' DescribeClustersResponse (Maybe Text)
describeClustersResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClustersResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeClustersResponse' :: DescribeClustersResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeClustersResponse
s@DescribeClustersResponse' {} Maybe Text
a -> DescribeClustersResponse
s {$sel:nextToken:DescribeClustersResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeClustersResponse)

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

instance Prelude.NFData DescribeClustersResponse where
  rnf :: DescribeClustersResponse -> ()
rnf DescribeClustersResponse' {Int
Maybe [Cluster]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
clusters :: Maybe [Cluster]
$sel:httpStatus:DescribeClustersResponse' :: DescribeClustersResponse -> Int
$sel:nextToken:DescribeClustersResponse' :: DescribeClustersResponse -> Maybe Text
$sel:clusters:DescribeClustersResponse' :: DescribeClustersResponse -> Maybe [Cluster]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Cluster]
clusters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus