{-# 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.DescribeParameters
-- 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 the detailed parameter list for a particular parameter group.
--
-- This operation returns paginated results.
module Amazonka.MemoryDb.DescribeParameters
  ( -- * Creating a Request
    DescribeParameters (..),
    newDescribeParameters,

    -- * Request Lenses
    describeParameters_maxResults,
    describeParameters_nextToken,
    describeParameters_parameterGroupName,

    -- * Destructuring the Response
    DescribeParametersResponse (..),
    newDescribeParametersResponse,

    -- * Response Lenses
    describeParametersResponse_nextToken,
    describeParametersResponse_parameters,
    describeParametersResponse_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:/ 'newDescribeParameters' smart constructor.
data DescribeParameters = DescribeParameters'
  { -- | 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.
    DescribeParameters -> 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.
    DescribeParameters -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | he name of a specific parameter group to return details for.
    DescribeParameters -> Text
parameterGroupName :: Prelude.Text
  }
  deriving (DescribeParameters -> DescribeParameters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeParameters -> DescribeParameters -> Bool
$c/= :: DescribeParameters -> DescribeParameters -> Bool
== :: DescribeParameters -> DescribeParameters -> Bool
$c== :: DescribeParameters -> DescribeParameters -> Bool
Prelude.Eq, ReadPrec [DescribeParameters]
ReadPrec DescribeParameters
Int -> ReadS DescribeParameters
ReadS [DescribeParameters]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeParameters]
$creadListPrec :: ReadPrec [DescribeParameters]
readPrec :: ReadPrec DescribeParameters
$creadPrec :: ReadPrec DescribeParameters
readList :: ReadS [DescribeParameters]
$creadList :: ReadS [DescribeParameters]
readsPrec :: Int -> ReadS DescribeParameters
$creadsPrec :: Int -> ReadS DescribeParameters
Prelude.Read, Int -> DescribeParameters -> ShowS
[DescribeParameters] -> ShowS
DescribeParameters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeParameters] -> ShowS
$cshowList :: [DescribeParameters] -> ShowS
show :: DescribeParameters -> String
$cshow :: DescribeParameters -> String
showsPrec :: Int -> DescribeParameters -> ShowS
$cshowsPrec :: Int -> DescribeParameters -> ShowS
Prelude.Show, forall x. Rep DescribeParameters x -> DescribeParameters
forall x. DescribeParameters -> Rep DescribeParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeParameters x -> DescribeParameters
$cfrom :: forall x. DescribeParameters -> Rep DescribeParameters x
Prelude.Generic)

-- |
-- Create a value of 'DescribeParameters' 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:
--
-- 'maxResults', 'describeParameters_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', 'describeParameters_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.
--
-- 'parameterGroupName', 'describeParameters_parameterGroupName' - he name of a specific parameter group to return details for.
newDescribeParameters ::
  -- | 'parameterGroupName'
  Prelude.Text ->
  DescribeParameters
newDescribeParameters :: Text -> DescribeParameters
newDescribeParameters Text
pParameterGroupName_ =
  DescribeParameters'
    { $sel:maxResults:DescribeParameters' :: Maybe Int
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeParameters' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:parameterGroupName:DescribeParameters' :: Text
parameterGroupName = Text
pParameterGroupName_
    }

-- | 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.
describeParameters_maxResults :: Lens.Lens' DescribeParameters (Prelude.Maybe Prelude.Int)
describeParameters_maxResults :: Lens' DescribeParameters (Maybe Int)
describeParameters_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParameters' {Maybe Int
maxResults :: Maybe Int
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Int
maxResults} -> Maybe Int
maxResults) (\s :: DescribeParameters
s@DescribeParameters' {} Maybe Int
a -> DescribeParameters
s {$sel:maxResults:DescribeParameters' :: Maybe Int
maxResults = Maybe Int
a} :: DescribeParameters)

-- | 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.
describeParameters_nextToken :: Lens.Lens' DescribeParameters (Prelude.Maybe Prelude.Text)
describeParameters_nextToken :: Lens' DescribeParameters (Maybe Text)
describeParameters_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParameters' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeParameters' :: DescribeParameters -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeParameters
s@DescribeParameters' {} Maybe Text
a -> DescribeParameters
s {$sel:nextToken:DescribeParameters' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeParameters)

-- | he name of a specific parameter group to return details for.
describeParameters_parameterGroupName :: Lens.Lens' DescribeParameters Prelude.Text
describeParameters_parameterGroupName :: Lens' DescribeParameters Text
describeParameters_parameterGroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParameters' {Text
parameterGroupName :: Text
$sel:parameterGroupName:DescribeParameters' :: DescribeParameters -> Text
parameterGroupName} -> Text
parameterGroupName) (\s :: DescribeParameters
s@DescribeParameters' {} Text
a -> DescribeParameters
s {$sel:parameterGroupName:DescribeParameters' :: Text
parameterGroupName = Text
a} :: DescribeParameters)

instance Core.AWSPager DescribeParameters where
  page :: DescribeParameters
-> AWSResponse DescribeParameters -> Maybe DescribeParameters
page DescribeParameters
rq AWSResponse DescribeParameters
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeParameters
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeParametersResponse (Maybe Text)
describeParametersResponse_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 DescribeParameters
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeParametersResponse (Maybe [Parameter])
describeParametersResponse_parameters
            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.$ DescribeParameters
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' DescribeParameters (Maybe Text)
describeParameters_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse DescribeParameters
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeParametersResponse (Maybe Text)
describeParametersResponse_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 DescribeParameters where
  type
    AWSResponse DescribeParameters =
      DescribeParametersResponse
  request :: (Service -> Service)
-> DescribeParameters -> Request DescribeParameters
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 DescribeParameters
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeParameters)))
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 Text
-> Maybe [Parameter] -> Int -> DescribeParametersResponse
DescribeParametersResponse'
            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
"NextToken")
            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
"Parameters" 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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable DescribeParameters where
  hashWithSalt :: Int -> DescribeParameters -> Int
hashWithSalt Int
_salt DescribeParameters' {Maybe Int
Maybe Text
Text
parameterGroupName :: Text
nextToken :: Maybe Text
maxResults :: Maybe Int
$sel:parameterGroupName:DescribeParameters' :: DescribeParameters -> Text
$sel:nextToken:DescribeParameters' :: DescribeParameters -> Maybe Text
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Int
..} =
    Int
_salt
      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` Text
parameterGroupName

instance Prelude.NFData DescribeParameters where
  rnf :: DescribeParameters -> ()
rnf DescribeParameters' {Maybe Int
Maybe Text
Text
parameterGroupName :: Text
nextToken :: Maybe Text
maxResults :: Maybe Int
$sel:parameterGroupName:DescribeParameters' :: DescribeParameters -> Text
$sel:nextToken:DescribeParameters' :: DescribeParameters -> Maybe Text
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Int
..} =
    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 Text
parameterGroupName

instance Data.ToHeaders DescribeParameters where
  toHeaders :: DescribeParameters -> 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.DescribeParameters" ::
                          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 DescribeParameters where
  toJSON :: DescribeParameters -> Value
toJSON DescribeParameters' {Maybe Int
Maybe Text
Text
parameterGroupName :: Text
nextToken :: Maybe Text
maxResults :: Maybe Int
$sel:parameterGroupName:DescribeParameters' :: DescribeParameters -> Text
$sel:nextToken:DescribeParameters' :: DescribeParameters -> Maybe Text
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Int
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ParameterGroupName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
parameterGroupName)
          ]
      )

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

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

-- | /See:/ 'newDescribeParametersResponse' smart constructor.
data DescribeParametersResponse = DescribeParametersResponse'
  { -- | 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.
    DescribeParametersResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of parameters specific to a particular parameter group. Each
    -- element in the list contains detailed information about one parameter.
    DescribeParametersResponse -> Maybe [Parameter]
parameters :: Prelude.Maybe [Parameter],
    -- | The response's http status code.
    DescribeParametersResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeParametersResponse -> DescribeParametersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeParametersResponse -> DescribeParametersResponse -> Bool
$c/= :: DescribeParametersResponse -> DescribeParametersResponse -> Bool
== :: DescribeParametersResponse -> DescribeParametersResponse -> Bool
$c== :: DescribeParametersResponse -> DescribeParametersResponse -> Bool
Prelude.Eq, ReadPrec [DescribeParametersResponse]
ReadPrec DescribeParametersResponse
Int -> ReadS DescribeParametersResponse
ReadS [DescribeParametersResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeParametersResponse]
$creadListPrec :: ReadPrec [DescribeParametersResponse]
readPrec :: ReadPrec DescribeParametersResponse
$creadPrec :: ReadPrec DescribeParametersResponse
readList :: ReadS [DescribeParametersResponse]
$creadList :: ReadS [DescribeParametersResponse]
readsPrec :: Int -> ReadS DescribeParametersResponse
$creadsPrec :: Int -> ReadS DescribeParametersResponse
Prelude.Read, Int -> DescribeParametersResponse -> ShowS
[DescribeParametersResponse] -> ShowS
DescribeParametersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeParametersResponse] -> ShowS
$cshowList :: [DescribeParametersResponse] -> ShowS
show :: DescribeParametersResponse -> String
$cshow :: DescribeParametersResponse -> String
showsPrec :: Int -> DescribeParametersResponse -> ShowS
$cshowsPrec :: Int -> DescribeParametersResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeParametersResponse x -> DescribeParametersResponse
forall x.
DescribeParametersResponse -> Rep DescribeParametersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeParametersResponse x -> DescribeParametersResponse
$cfrom :: forall x.
DescribeParametersResponse -> Rep DescribeParametersResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeParametersResponse' 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:
--
-- 'nextToken', 'describeParametersResponse_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.
--
-- 'parameters', 'describeParametersResponse_parameters' - A list of parameters specific to a particular parameter group. Each
-- element in the list contains detailed information about one parameter.
--
-- 'httpStatus', 'describeParametersResponse_httpStatus' - The response's http status code.
newDescribeParametersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeParametersResponse
newDescribeParametersResponse :: Int -> DescribeParametersResponse
newDescribeParametersResponse Int
pHttpStatus_ =
  DescribeParametersResponse'
    { $sel:nextToken:DescribeParametersResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:parameters:DescribeParametersResponse' :: Maybe [Parameter]
parameters = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeParametersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | 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.
describeParametersResponse_nextToken :: Lens.Lens' DescribeParametersResponse (Prelude.Maybe Prelude.Text)
describeParametersResponse_nextToken :: Lens' DescribeParametersResponse (Maybe Text)
describeParametersResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParametersResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeParametersResponse' :: DescribeParametersResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeParametersResponse
s@DescribeParametersResponse' {} Maybe Text
a -> DescribeParametersResponse
s {$sel:nextToken:DescribeParametersResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeParametersResponse)

-- | A list of parameters specific to a particular parameter group. Each
-- element in the list contains detailed information about one parameter.
describeParametersResponse_parameters :: Lens.Lens' DescribeParametersResponse (Prelude.Maybe [Parameter])
describeParametersResponse_parameters :: Lens' DescribeParametersResponse (Maybe [Parameter])
describeParametersResponse_parameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParametersResponse' {Maybe [Parameter]
parameters :: Maybe [Parameter]
$sel:parameters:DescribeParametersResponse' :: DescribeParametersResponse -> Maybe [Parameter]
parameters} -> Maybe [Parameter]
parameters) (\s :: DescribeParametersResponse
s@DescribeParametersResponse' {} Maybe [Parameter]
a -> DescribeParametersResponse
s {$sel:parameters:DescribeParametersResponse' :: Maybe [Parameter]
parameters = Maybe [Parameter]
a} :: DescribeParametersResponse) 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 response's http status code.
describeParametersResponse_httpStatus :: Lens.Lens' DescribeParametersResponse Prelude.Int
describeParametersResponse_httpStatus :: Lens' DescribeParametersResponse Int
describeParametersResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParametersResponse' {Int
httpStatus :: Int
$sel:httpStatus:DescribeParametersResponse' :: DescribeParametersResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: DescribeParametersResponse
s@DescribeParametersResponse' {} Int
a -> DescribeParametersResponse
s {$sel:httpStatus:DescribeParametersResponse' :: Int
httpStatus = Int
a} :: DescribeParametersResponse)

instance Prelude.NFData DescribeParametersResponse where
  rnf :: DescribeParametersResponse -> ()
rnf DescribeParametersResponse' {Int
Maybe [Parameter]
Maybe Text
httpStatus :: Int
parameters :: Maybe [Parameter]
nextToken :: Maybe Text
$sel:httpStatus:DescribeParametersResponse' :: DescribeParametersResponse -> Int
$sel:parameters:DescribeParametersResponse' :: DescribeParametersResponse -> Maybe [Parameter]
$sel:nextToken:DescribeParametersResponse' :: DescribeParametersResponse -> Maybe Text
..} =
    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 [Parameter]
parameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus