{-# 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.SSM.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)
--
-- Get information about a parameter.
--
-- Request results are returned on a best-effort basis. If you specify
-- @MaxResults@ in the request, the response includes information up to the
-- limit specified. The number of items returned, however, can be between
-- zero and the value of @MaxResults@. If the service reaches an internal
-- limit while processing the results, it stops the operation and returns
-- the matching values up to that point and a @NextToken@. You can specify
-- the @NextToken@ in a subsequent call to get the next set of results.
--
-- If you change the KMS key alias for the KMS key used to encrypt a
-- parameter, then you must also update the key alias the parameter uses to
-- reference KMS. Otherwise, @DescribeParameters@ retrieves whatever the
-- original key alias was referencing.
--
-- This operation returns paginated results.
module Amazonka.SSM.DescribeParameters
  ( -- * Creating a Request
    DescribeParameters (..),
    newDescribeParameters,

    -- * Request Lenses
    describeParameters_filters,
    describeParameters_maxResults,
    describeParameters_nextToken,
    describeParameters_parameterFilters,

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

-- | /See:/ 'newDescribeParameters' smart constructor.
data DescribeParameters = DescribeParameters'
  { -- | This data type is deprecated. Instead, use @ParameterFilters@.
    DescribeParameters -> Maybe [ParametersFilter]
filters :: Prelude.Maybe [ParametersFilter],
    -- | The maximum number of items to return for this call. The call also
    -- returns a token that you can specify in a subsequent call to get the
    -- next set of results.
    DescribeParameters -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token for the next set of items to return. (You received this token
    -- from a previous call.)
    DescribeParameters -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Filters to limit the request results.
    DescribeParameters -> Maybe [ParameterStringFilter]
parameterFilters :: Prelude.Maybe [ParameterStringFilter]
  }
  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:
--
-- 'filters', 'describeParameters_filters' - This data type is deprecated. Instead, use @ParameterFilters@.
--
-- 'maxResults', 'describeParameters_maxResults' - The maximum number of items to return for this call. The call also
-- returns a token that you can specify in a subsequent call to get the
-- next set of results.
--
-- 'nextToken', 'describeParameters_nextToken' - The token for the next set of items to return. (You received this token
-- from a previous call.)
--
-- 'parameterFilters', 'describeParameters_parameterFilters' - Filters to limit the request results.
newDescribeParameters ::
  DescribeParameters
newDescribeParameters :: DescribeParameters
newDescribeParameters =
  DescribeParameters'
    { $sel:filters:DescribeParameters' :: Maybe [ParametersFilter]
filters = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:DescribeParameters' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeParameters' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:parameterFilters:DescribeParameters' :: Maybe [ParameterStringFilter]
parameterFilters = forall a. Maybe a
Prelude.Nothing
    }

-- | This data type is deprecated. Instead, use @ParameterFilters@.
describeParameters_filters :: Lens.Lens' DescribeParameters (Prelude.Maybe [ParametersFilter])
describeParameters_filters :: Lens' DescribeParameters (Maybe [ParametersFilter])
describeParameters_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParameters' {Maybe [ParametersFilter]
filters :: Maybe [ParametersFilter]
$sel:filters:DescribeParameters' :: DescribeParameters -> Maybe [ParametersFilter]
filters} -> Maybe [ParametersFilter]
filters) (\s :: DescribeParameters
s@DescribeParameters' {} Maybe [ParametersFilter]
a -> DescribeParameters
s {$sel:filters:DescribeParameters' :: Maybe [ParametersFilter]
filters = Maybe [ParametersFilter]
a} :: DescribeParameters) 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 items to return for this call. The call also
-- returns a token that you can specify in a subsequent call to get the
-- next set of results.
describeParameters_maxResults :: Lens.Lens' DescribeParameters (Prelude.Maybe Prelude.Natural)
describeParameters_maxResults :: Lens' DescribeParameters (Maybe Natural)
describeParameters_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParameters' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: DescribeParameters
s@DescribeParameters' {} Maybe Natural
a -> DescribeParameters
s {$sel:maxResults:DescribeParameters' :: Maybe Natural
maxResults = Maybe Natural
a} :: DescribeParameters)

-- | The token for the next set of items to return. (You received this token
-- from a previous call.)
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)

-- | Filters to limit the request results.
describeParameters_parameterFilters :: Lens.Lens' DescribeParameters (Prelude.Maybe [ParameterStringFilter])
describeParameters_parameterFilters :: Lens' DescribeParameters (Maybe [ParameterStringFilter])
describeParameters_parameterFilters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParameters' {Maybe [ParameterStringFilter]
parameterFilters :: Maybe [ParameterStringFilter]
$sel:parameterFilters:DescribeParameters' :: DescribeParameters -> Maybe [ParameterStringFilter]
parameterFilters} -> Maybe [ParameterStringFilter]
parameterFilters) (\s :: DescribeParameters
s@DescribeParameters' {} Maybe [ParameterStringFilter]
a -> DescribeParameters
s {$sel:parameterFilters:DescribeParameters' :: Maybe [ParameterStringFilter]
parameterFilters = Maybe [ParameterStringFilter]
a} :: DescribeParameters) 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

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

instance Prelude.NFData DescribeParameters where
  rnf :: DescribeParameters -> ()
rnf DescribeParameters' {Maybe Natural
Maybe [ParameterStringFilter]
Maybe [ParametersFilter]
Maybe Text
parameterFilters :: Maybe [ParameterStringFilter]
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [ParametersFilter]
$sel:parameterFilters:DescribeParameters' :: DescribeParameters -> Maybe [ParameterStringFilter]
$sel:nextToken:DescribeParameters' :: DescribeParameters -> Maybe Text
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Natural
$sel:filters:DescribeParameters' :: DescribeParameters -> Maybe [ParametersFilter]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ParametersFilter]
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
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ParameterStringFilter]
parameterFilters

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
"AmazonSSM.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 Natural
Maybe [ParameterStringFilter]
Maybe [ParametersFilter]
Maybe Text
parameterFilters :: Maybe [ParameterStringFilter]
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [ParametersFilter]
$sel:parameterFilters:DescribeParameters' :: DescribeParameters -> Maybe [ParameterStringFilter]
$sel:nextToken:DescribeParameters' :: DescribeParameters -> Maybe Text
$sel:maxResults:DescribeParameters' :: DescribeParameters -> Maybe Natural
$sel:filters:DescribeParameters' :: DescribeParameters -> Maybe [ParametersFilter]
..} =
    [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 [ParametersFilter]
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,
            (Key
"ParameterFilters" 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 [ParameterStringFilter]
parameterFilters
          ]
      )

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'
  { -- | The token to use when requesting the next set of items.
    DescribeParametersResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Parameters returned by the request.
    DescribeParametersResponse -> Maybe [ParameterMetadata]
parameters :: Prelude.Maybe [ParameterMetadata],
    -- | 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' - The token to use when requesting the next set of items.
--
-- 'parameters', 'describeParametersResponse_parameters' - Parameters returned by the request.
--
-- '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 [ParameterMetadata]
parameters = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeParametersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The token to use when requesting the next set of items.
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)

-- | Parameters returned by the request.
describeParametersResponse_parameters :: Lens.Lens' DescribeParametersResponse (Prelude.Maybe [ParameterMetadata])
describeParametersResponse_parameters :: Lens' DescribeParametersResponse (Maybe [ParameterMetadata])
describeParametersResponse_parameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeParametersResponse' {Maybe [ParameterMetadata]
parameters :: Maybe [ParameterMetadata]
$sel:parameters:DescribeParametersResponse' :: DescribeParametersResponse -> Maybe [ParameterMetadata]
parameters} -> Maybe [ParameterMetadata]
parameters) (\s :: DescribeParametersResponse
s@DescribeParametersResponse' {} Maybe [ParameterMetadata]
a -> DescribeParametersResponse
s {$sel:parameters:DescribeParametersResponse' :: Maybe [ParameterMetadata]
parameters = Maybe [ParameterMetadata]
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 [ParameterMetadata]
Maybe Text
httpStatus :: Int
parameters :: Maybe [ParameterMetadata]
nextToken :: Maybe Text
$sel:httpStatus:DescribeParametersResponse' :: DescribeParametersResponse -> Int
$sel:parameters:DescribeParametersResponse' :: DescribeParametersResponse -> Maybe [ParameterMetadata]
$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 [ParameterMetadata]
parameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus