{-# 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.CloudHSMV2.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)
--
-- Gets information about AWS CloudHSM clusters.
--
-- This is a paginated operation, which means that each response might
-- contain only a subset of all the clusters. When the response contains
-- only a subset of clusters, it includes a @NextToken@ value. Use this
-- value in a subsequent @DescribeClusters@ request to get more clusters.
-- When you receive a response with no @NextToken@ (or an empty or null
-- value), that means there are no more clusters to get.
--
-- This operation returns paginated results.
module Amazonka.CloudHSMV2.DescribeClusters
  ( -- * Creating a Request
    DescribeClusters (..),
    newDescribeClusters,

    -- * Request Lenses
    describeClusters_filters,
    describeClusters_maxResults,
    describeClusters_nextToken,

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

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

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

-- | /See:/ 'newDescribeClusters' smart constructor.
data DescribeClusters = DescribeClusters'
  { -- | One or more filters to limit the items returned in the response.
    --
    -- Use the @clusterIds@ filter to return only the specified clusters.
    -- Specify clusters by their cluster identifier (ID).
    --
    -- Use the @vpcIds@ filter to return only the clusters in the specified
    -- virtual private clouds (VPCs). Specify VPCs by their VPC identifier
    -- (ID).
    --
    -- Use the @states@ filter to return only clusters that match the specified
    -- state.
    DescribeClusters -> Maybe (HashMap Text [Text])
filters :: Prelude.Maybe (Prelude.HashMap Prelude.Text [Prelude.Text]),
    -- | The maximum number of clusters to return in the response. When there are
    -- more clusters than the number you specify, the response contains a
    -- @NextToken@ value.
    DescribeClusters -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The @NextToken@ value that you received in the previous response. Use
    -- this value to get more clusters.
    DescribeClusters -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  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:
--
-- 'filters', 'describeClusters_filters' - One or more filters to limit the items returned in the response.
--
-- Use the @clusterIds@ filter to return only the specified clusters.
-- Specify clusters by their cluster identifier (ID).
--
-- Use the @vpcIds@ filter to return only the clusters in the specified
-- virtual private clouds (VPCs). Specify VPCs by their VPC identifier
-- (ID).
--
-- Use the @states@ filter to return only clusters that match the specified
-- state.
--
-- 'maxResults', 'describeClusters_maxResults' - The maximum number of clusters to return in the response. When there are
-- more clusters than the number you specify, the response contains a
-- @NextToken@ value.
--
-- 'nextToken', 'describeClusters_nextToken' - The @NextToken@ value that you received in the previous response. Use
-- this value to get more clusters.
newDescribeClusters ::
  DescribeClusters
newDescribeClusters :: DescribeClusters
newDescribeClusters =
  DescribeClusters'
    { $sel:filters:DescribeClusters' :: Maybe (HashMap Text [Text])
filters = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:DescribeClusters' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeClusters' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | One or more filters to limit the items returned in the response.
--
-- Use the @clusterIds@ filter to return only the specified clusters.
-- Specify clusters by their cluster identifier (ID).
--
-- Use the @vpcIds@ filter to return only the clusters in the specified
-- virtual private clouds (VPCs). Specify VPCs by their VPC identifier
-- (ID).
--
-- Use the @states@ filter to return only clusters that match the specified
-- state.
describeClusters_filters :: Lens.Lens' DescribeClusters (Prelude.Maybe (Prelude.HashMap Prelude.Text [Prelude.Text]))
describeClusters_filters :: Lens' DescribeClusters (Maybe (HashMap Text [Text]))
describeClusters_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClusters' {Maybe (HashMap Text [Text])
filters :: Maybe (HashMap Text [Text])
$sel:filters:DescribeClusters' :: DescribeClusters -> Maybe (HashMap Text [Text])
filters} -> Maybe (HashMap Text [Text])
filters) (\s :: DescribeClusters
s@DescribeClusters' {} Maybe (HashMap Text [Text])
a -> DescribeClusters
s {$sel:filters:DescribeClusters' :: Maybe (HashMap Text [Text])
filters = Maybe (HashMap Text [Text])
a} :: DescribeClusters) 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 maximum number of clusters to return in the response. When there are
-- more clusters than the number you specify, the response contains a
-- @NextToken@ value.
describeClusters_maxResults :: Lens.Lens' DescribeClusters (Prelude.Maybe Prelude.Natural)
describeClusters_maxResults :: Lens' DescribeClusters (Maybe Natural)
describeClusters_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeClusters' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: DescribeClusters
s@DescribeClusters' {} Maybe Natural
a -> DescribeClusters
s {$sel:maxResults:DescribeClusters' :: Maybe Natural
maxResults = Maybe Natural
a} :: DescribeClusters)

-- | The @NextToken@ value that you received in the previous response. Use
-- this value to get more clusters.
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)

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 Natural
Maybe Text
Maybe (HashMap Text [Text])
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe (HashMap Text [Text])
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Natural
$sel:filters:DescribeClusters' :: DescribeClusters -> Maybe (HashMap Text [Text])
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text [Text])
filters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData DescribeClusters where
  rnf :: DescribeClusters -> ()
rnf DescribeClusters' {Maybe Natural
Maybe Text
Maybe (HashMap Text [Text])
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe (HashMap Text [Text])
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Natural
$sel:filters:DescribeClusters' :: DescribeClusters -> Maybe (HashMap Text [Text])
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text [Text])
filters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

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
"BaldrApiService.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 Natural
Maybe Text
Maybe (HashMap Text [Text])
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe (HashMap Text [Text])
$sel:nextToken:DescribeClusters' :: DescribeClusters -> Maybe Text
$sel:maxResults:DescribeClusters' :: DescribeClusters -> Maybe Natural
$sel:filters:DescribeClusters' :: DescribeClusters -> Maybe (HashMap Text [Text])
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Filters" 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 (HashMap Text [Text])
filters,
            (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 Natural
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
          ]
      )

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 opaque string that indicates that the response contains only a subset
    -- of clusters. Use this value in a subsequent @DescribeClusters@ request
    -- to get more clusters.
    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 opaque string that indicates that the response contains only a subset
-- of clusters. Use this value in a subsequent @DescribeClusters@ request
-- to get more clusters.
--
-- '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 opaque string that indicates that the response contains only a subset
-- of clusters. Use this value in a subsequent @DescribeClusters@ request
-- to get more clusters.
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