{-# 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.DAX.DescribeDefaultParameters
-- 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 default system parameter information for the DAX caching
-- software.
--
-- This operation returns paginated results.
module Amazonka.DAX.DescribeDefaultParameters
  ( -- * Creating a Request
    DescribeDefaultParameters (..),
    newDescribeDefaultParameters,

    -- * Request Lenses
    describeDefaultParameters_maxResults,
    describeDefaultParameters_nextToken,

    -- * Destructuring the Response
    DescribeDefaultParametersResponse (..),
    newDescribeDefaultParametersResponse,

    -- * Response Lenses
    describeDefaultParametersResponse_nextToken,
    describeDefaultParametersResponse_parameters,
    describeDefaultParametersResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import Amazonka.DAX.Types
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:/ 'newDescribeDefaultParameters' smart constructor.
data DescribeDefaultParameters = DescribeDefaultParameters'
  { -- | The maximum number of results to include in the response. If more
    -- results exist than the specified @MaxResults@ value, a token is included
    -- in the response so that the remaining results can be retrieved.
    --
    -- The value for @MaxResults@ must be between 20 and 100.
    DescribeDefaultParameters -> Maybe Int
maxResults :: Prelude.Maybe Prelude.Int,
    -- | An optional token returned from a prior request. Use this token for
    -- pagination of results from this action. If this parameter is specified,
    -- the response includes only results beyond the token, up to the value
    -- specified by @MaxResults@.
    DescribeDefaultParameters -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (DescribeDefaultParameters -> DescribeDefaultParameters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeDefaultParameters -> DescribeDefaultParameters -> Bool
$c/= :: DescribeDefaultParameters -> DescribeDefaultParameters -> Bool
== :: DescribeDefaultParameters -> DescribeDefaultParameters -> Bool
$c== :: DescribeDefaultParameters -> DescribeDefaultParameters -> Bool
Prelude.Eq, ReadPrec [DescribeDefaultParameters]
ReadPrec DescribeDefaultParameters
Int -> ReadS DescribeDefaultParameters
ReadS [DescribeDefaultParameters]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeDefaultParameters]
$creadListPrec :: ReadPrec [DescribeDefaultParameters]
readPrec :: ReadPrec DescribeDefaultParameters
$creadPrec :: ReadPrec DescribeDefaultParameters
readList :: ReadS [DescribeDefaultParameters]
$creadList :: ReadS [DescribeDefaultParameters]
readsPrec :: Int -> ReadS DescribeDefaultParameters
$creadsPrec :: Int -> ReadS DescribeDefaultParameters
Prelude.Read, Int -> DescribeDefaultParameters -> ShowS
[DescribeDefaultParameters] -> ShowS
DescribeDefaultParameters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeDefaultParameters] -> ShowS
$cshowList :: [DescribeDefaultParameters] -> ShowS
show :: DescribeDefaultParameters -> String
$cshow :: DescribeDefaultParameters -> String
showsPrec :: Int -> DescribeDefaultParameters -> ShowS
$cshowsPrec :: Int -> DescribeDefaultParameters -> ShowS
Prelude.Show, forall x.
Rep DescribeDefaultParameters x -> DescribeDefaultParameters
forall x.
DescribeDefaultParameters -> Rep DescribeDefaultParameters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeDefaultParameters x -> DescribeDefaultParameters
$cfrom :: forall x.
DescribeDefaultParameters -> Rep DescribeDefaultParameters x
Prelude.Generic)

-- |
-- Create a value of 'DescribeDefaultParameters' 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', 'describeDefaultParameters_maxResults' - The maximum number of results to include in the response. If more
-- results exist than the specified @MaxResults@ value, a token is included
-- in the response so that the remaining results can be retrieved.
--
-- The value for @MaxResults@ must be between 20 and 100.
--
-- 'nextToken', 'describeDefaultParameters_nextToken' - An optional token returned from a prior request. Use this token for
-- pagination of results from this action. If this parameter is specified,
-- the response includes only results beyond the token, up to the value
-- specified by @MaxResults@.
newDescribeDefaultParameters ::
  DescribeDefaultParameters
newDescribeDefaultParameters :: DescribeDefaultParameters
newDescribeDefaultParameters =
  DescribeDefaultParameters'
    { $sel:maxResults:DescribeDefaultParameters' :: Maybe Int
maxResults =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeDefaultParameters' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

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

-- | An optional token returned from a prior request. Use this token for
-- pagination of results from this action. If this parameter is specified,
-- the response includes only results beyond the token, up to the value
-- specified by @MaxResults@.
describeDefaultParameters_nextToken :: Lens.Lens' DescribeDefaultParameters (Prelude.Maybe Prelude.Text)
describeDefaultParameters_nextToken :: Lens' DescribeDefaultParameters (Maybe Text)
describeDefaultParameters_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeDefaultParameters' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeDefaultParameters' :: DescribeDefaultParameters -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeDefaultParameters
s@DescribeDefaultParameters' {} Maybe Text
a -> DescribeDefaultParameters
s {$sel:nextToken:DescribeDefaultParameters' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeDefaultParameters)

instance Core.AWSPager DescribeDefaultParameters where
  page :: DescribeDefaultParameters
-> AWSResponse DescribeDefaultParameters
-> Maybe DescribeDefaultParameters
page DescribeDefaultParameters
rq AWSResponse DescribeDefaultParameters
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeDefaultParameters
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeDefaultParametersResponse (Maybe Text)
describeDefaultParametersResponse_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 DescribeDefaultParameters
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeDefaultParametersResponse (Maybe [Parameter])
describeDefaultParametersResponse_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.$ DescribeDefaultParameters
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' DescribeDefaultParameters (Maybe Text)
describeDefaultParameters_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse DescribeDefaultParameters
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeDefaultParametersResponse (Maybe Text)
describeDefaultParametersResponse_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 DescribeDefaultParameters where
  type
    AWSResponse DescribeDefaultParameters =
      DescribeDefaultParametersResponse
  request :: (Service -> Service)
-> DescribeDefaultParameters -> Request DescribeDefaultParameters
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 DescribeDefaultParameters
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeDefaultParameters)))
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 -> DescribeDefaultParametersResponse
DescribeDefaultParametersResponse'
            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 DescribeDefaultParameters where
  hashWithSalt :: Int -> DescribeDefaultParameters -> Int
hashWithSalt Int
_salt DescribeDefaultParameters' {Maybe Int
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Int
$sel:nextToken:DescribeDefaultParameters' :: DescribeDefaultParameters -> Maybe Text
$sel:maxResults:DescribeDefaultParameters' :: DescribeDefaultParameters -> 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

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

instance Data.ToHeaders DescribeDefaultParameters where
  toHeaders :: DescribeDefaultParameters -> 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
"AmazonDAXV3.DescribeDefaultParameters" ::
                          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 DescribeDefaultParameters where
  toJSON :: DescribeDefaultParameters -> Value
toJSON DescribeDefaultParameters' {Maybe Int
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Int
$sel:nextToken:DescribeDefaultParameters' :: DescribeDefaultParameters -> Maybe Text
$sel:maxResults:DescribeDefaultParameters' :: DescribeDefaultParameters -> 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
          ]
      )

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

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

-- | /See:/ 'newDescribeDefaultParametersResponse' smart constructor.
data DescribeDefaultParametersResponse = DescribeDefaultParametersResponse'
  { -- | Provides an identifier to allow retrieval of paginated results.
    DescribeDefaultParametersResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of parameters. Each element in the list represents one parameter.
    DescribeDefaultParametersResponse -> Maybe [Parameter]
parameters :: Prelude.Maybe [Parameter],
    -- | The response's http status code.
    DescribeDefaultParametersResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeDefaultParametersResponse
-> DescribeDefaultParametersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeDefaultParametersResponse
-> DescribeDefaultParametersResponse -> Bool
$c/= :: DescribeDefaultParametersResponse
-> DescribeDefaultParametersResponse -> Bool
== :: DescribeDefaultParametersResponse
-> DescribeDefaultParametersResponse -> Bool
$c== :: DescribeDefaultParametersResponse
-> DescribeDefaultParametersResponse -> Bool
Prelude.Eq, ReadPrec [DescribeDefaultParametersResponse]
ReadPrec DescribeDefaultParametersResponse
Int -> ReadS DescribeDefaultParametersResponse
ReadS [DescribeDefaultParametersResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeDefaultParametersResponse]
$creadListPrec :: ReadPrec [DescribeDefaultParametersResponse]
readPrec :: ReadPrec DescribeDefaultParametersResponse
$creadPrec :: ReadPrec DescribeDefaultParametersResponse
readList :: ReadS [DescribeDefaultParametersResponse]
$creadList :: ReadS [DescribeDefaultParametersResponse]
readsPrec :: Int -> ReadS DescribeDefaultParametersResponse
$creadsPrec :: Int -> ReadS DescribeDefaultParametersResponse
Prelude.Read, Int -> DescribeDefaultParametersResponse -> ShowS
[DescribeDefaultParametersResponse] -> ShowS
DescribeDefaultParametersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeDefaultParametersResponse] -> ShowS
$cshowList :: [DescribeDefaultParametersResponse] -> ShowS
show :: DescribeDefaultParametersResponse -> String
$cshow :: DescribeDefaultParametersResponse -> String
showsPrec :: Int -> DescribeDefaultParametersResponse -> ShowS
$cshowsPrec :: Int -> DescribeDefaultParametersResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeDefaultParametersResponse x
-> DescribeDefaultParametersResponse
forall x.
DescribeDefaultParametersResponse
-> Rep DescribeDefaultParametersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeDefaultParametersResponse x
-> DescribeDefaultParametersResponse
$cfrom :: forall x.
DescribeDefaultParametersResponse
-> Rep DescribeDefaultParametersResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeDefaultParametersResponse' 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', 'describeDefaultParametersResponse_nextToken' - Provides an identifier to allow retrieval of paginated results.
--
-- 'parameters', 'describeDefaultParametersResponse_parameters' - A list of parameters. Each element in the list represents one parameter.
--
-- 'httpStatus', 'describeDefaultParametersResponse_httpStatus' - The response's http status code.
newDescribeDefaultParametersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeDefaultParametersResponse
newDescribeDefaultParametersResponse :: Int -> DescribeDefaultParametersResponse
newDescribeDefaultParametersResponse Int
pHttpStatus_ =
  DescribeDefaultParametersResponse'
    { $sel:nextToken:DescribeDefaultParametersResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:parameters:DescribeDefaultParametersResponse' :: Maybe [Parameter]
parameters = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeDefaultParametersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Provides an identifier to allow retrieval of paginated results.
describeDefaultParametersResponse_nextToken :: Lens.Lens' DescribeDefaultParametersResponse (Prelude.Maybe Prelude.Text)
describeDefaultParametersResponse_nextToken :: Lens' DescribeDefaultParametersResponse (Maybe Text)
describeDefaultParametersResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeDefaultParametersResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeDefaultParametersResponse' :: DescribeDefaultParametersResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeDefaultParametersResponse
s@DescribeDefaultParametersResponse' {} Maybe Text
a -> DescribeDefaultParametersResponse
s {$sel:nextToken:DescribeDefaultParametersResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeDefaultParametersResponse)

-- | A list of parameters. Each element in the list represents one parameter.
describeDefaultParametersResponse_parameters :: Lens.Lens' DescribeDefaultParametersResponse (Prelude.Maybe [Parameter])
describeDefaultParametersResponse_parameters :: Lens' DescribeDefaultParametersResponse (Maybe [Parameter])
describeDefaultParametersResponse_parameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeDefaultParametersResponse' {Maybe [Parameter]
parameters :: Maybe [Parameter]
$sel:parameters:DescribeDefaultParametersResponse' :: DescribeDefaultParametersResponse -> Maybe [Parameter]
parameters} -> Maybe [Parameter]
parameters) (\s :: DescribeDefaultParametersResponse
s@DescribeDefaultParametersResponse' {} Maybe [Parameter]
a -> DescribeDefaultParametersResponse
s {$sel:parameters:DescribeDefaultParametersResponse' :: Maybe [Parameter]
parameters = Maybe [Parameter]
a} :: DescribeDefaultParametersResponse) 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.
describeDefaultParametersResponse_httpStatus :: Lens.Lens' DescribeDefaultParametersResponse Prelude.Int
describeDefaultParametersResponse_httpStatus :: Lens' DescribeDefaultParametersResponse Int
describeDefaultParametersResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeDefaultParametersResponse' {Int
httpStatus :: Int
$sel:httpStatus:DescribeDefaultParametersResponse' :: DescribeDefaultParametersResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: DescribeDefaultParametersResponse
s@DescribeDefaultParametersResponse' {} Int
a -> DescribeDefaultParametersResponse
s {$sel:httpStatus:DescribeDefaultParametersResponse' :: Int
httpStatus = Int
a} :: DescribeDefaultParametersResponse)

instance
  Prelude.NFData
    DescribeDefaultParametersResponse
  where
  rnf :: DescribeDefaultParametersResponse -> ()
rnf DescribeDefaultParametersResponse' {Int
Maybe [Parameter]
Maybe Text
httpStatus :: Int
parameters :: Maybe [Parameter]
nextToken :: Maybe Text
$sel:httpStatus:DescribeDefaultParametersResponse' :: DescribeDefaultParametersResponse -> Int
$sel:parameters:DescribeDefaultParametersResponse' :: DescribeDefaultParametersResponse -> Maybe [Parameter]
$sel:nextToken:DescribeDefaultParametersResponse' :: DescribeDefaultParametersResponse -> 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