{-# 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.KafkaConnect.ListWorkerConfigurations
-- 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 a list of all of the worker configurations in this account and
-- Region.
--
-- This operation returns paginated results.
module Amazonka.KafkaConnect.ListWorkerConfigurations
  ( -- * Creating a Request
    ListWorkerConfigurations (..),
    newListWorkerConfigurations,

    -- * Request Lenses
    listWorkerConfigurations_maxResults,
    listWorkerConfigurations_nextToken,

    -- * Destructuring the Response
    ListWorkerConfigurationsResponse (..),
    newListWorkerConfigurationsResponse,

    -- * Response Lenses
    listWorkerConfigurationsResponse_nextToken,
    listWorkerConfigurationsResponse_workerConfigurations,
    listWorkerConfigurationsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListWorkerConfigurations' smart constructor.
data ListWorkerConfigurations = ListWorkerConfigurations'
  { -- | The maximum number of worker configurations to list in one response.
    ListWorkerConfigurations -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | If the response of a ListWorkerConfigurations operation is truncated, it
    -- will include a NextToken. Send this NextToken in a subsequent request to
    -- continue listing from where the previous operation left off.
    ListWorkerConfigurations -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListWorkerConfigurations -> ListWorkerConfigurations -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListWorkerConfigurations -> ListWorkerConfigurations -> Bool
$c/= :: ListWorkerConfigurations -> ListWorkerConfigurations -> Bool
== :: ListWorkerConfigurations -> ListWorkerConfigurations -> Bool
$c== :: ListWorkerConfigurations -> ListWorkerConfigurations -> Bool
Prelude.Eq, ReadPrec [ListWorkerConfigurations]
ReadPrec ListWorkerConfigurations
Int -> ReadS ListWorkerConfigurations
ReadS [ListWorkerConfigurations]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListWorkerConfigurations]
$creadListPrec :: ReadPrec [ListWorkerConfigurations]
readPrec :: ReadPrec ListWorkerConfigurations
$creadPrec :: ReadPrec ListWorkerConfigurations
readList :: ReadS [ListWorkerConfigurations]
$creadList :: ReadS [ListWorkerConfigurations]
readsPrec :: Int -> ReadS ListWorkerConfigurations
$creadsPrec :: Int -> ReadS ListWorkerConfigurations
Prelude.Read, Int -> ListWorkerConfigurations -> ShowS
[ListWorkerConfigurations] -> ShowS
ListWorkerConfigurations -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListWorkerConfigurations] -> ShowS
$cshowList :: [ListWorkerConfigurations] -> ShowS
show :: ListWorkerConfigurations -> String
$cshow :: ListWorkerConfigurations -> String
showsPrec :: Int -> ListWorkerConfigurations -> ShowS
$cshowsPrec :: Int -> ListWorkerConfigurations -> ShowS
Prelude.Show, forall x.
Rep ListWorkerConfigurations x -> ListWorkerConfigurations
forall x.
ListWorkerConfigurations -> Rep ListWorkerConfigurations x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListWorkerConfigurations x -> ListWorkerConfigurations
$cfrom :: forall x.
ListWorkerConfigurations -> Rep ListWorkerConfigurations x
Prelude.Generic)

-- |
-- Create a value of 'ListWorkerConfigurations' 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', 'listWorkerConfigurations_maxResults' - The maximum number of worker configurations to list in one response.
--
-- 'nextToken', 'listWorkerConfigurations_nextToken' - If the response of a ListWorkerConfigurations operation is truncated, it
-- will include a NextToken. Send this NextToken in a subsequent request to
-- continue listing from where the previous operation left off.
newListWorkerConfigurations ::
  ListWorkerConfigurations
newListWorkerConfigurations :: ListWorkerConfigurations
newListWorkerConfigurations =
  ListWorkerConfigurations'
    { $sel:maxResults:ListWorkerConfigurations' :: Maybe Natural
maxResults =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListWorkerConfigurations' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The maximum number of worker configurations to list in one response.
listWorkerConfigurations_maxResults :: Lens.Lens' ListWorkerConfigurations (Prelude.Maybe Prelude.Natural)
listWorkerConfigurations_maxResults :: Lens' ListWorkerConfigurations (Maybe Natural)
listWorkerConfigurations_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkerConfigurations' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListWorkerConfigurations
s@ListWorkerConfigurations' {} Maybe Natural
a -> ListWorkerConfigurations
s {$sel:maxResults:ListWorkerConfigurations' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListWorkerConfigurations)

-- | If the response of a ListWorkerConfigurations operation is truncated, it
-- will include a NextToken. Send this NextToken in a subsequent request to
-- continue listing from where the previous operation left off.
listWorkerConfigurations_nextToken :: Lens.Lens' ListWorkerConfigurations (Prelude.Maybe Prelude.Text)
listWorkerConfigurations_nextToken :: Lens' ListWorkerConfigurations (Maybe Text)
listWorkerConfigurations_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkerConfigurations' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListWorkerConfigurations
s@ListWorkerConfigurations' {} Maybe Text
a -> ListWorkerConfigurations
s {$sel:nextToken:ListWorkerConfigurations' :: Maybe Text
nextToken = Maybe Text
a} :: ListWorkerConfigurations)

instance Core.AWSPager ListWorkerConfigurations where
  page :: ListWorkerConfigurations
-> AWSResponse ListWorkerConfigurations
-> Maybe ListWorkerConfigurations
page ListWorkerConfigurations
rq AWSResponse ListWorkerConfigurations
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListWorkerConfigurations
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListWorkerConfigurationsResponse (Maybe Text)
listWorkerConfigurationsResponse_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 ListWorkerConfigurations
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListWorkerConfigurationsResponse
  (Maybe [WorkerConfigurationSummary])
listWorkerConfigurationsResponse_workerConfigurations
            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.$ ListWorkerConfigurations
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListWorkerConfigurations (Maybe Text)
listWorkerConfigurations_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListWorkerConfigurations
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListWorkerConfigurationsResponse (Maybe Text)
listWorkerConfigurationsResponse_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 ListWorkerConfigurations where
  type
    AWSResponse ListWorkerConfigurations =
      ListWorkerConfigurationsResponse
  request :: (Service -> Service)
-> ListWorkerConfigurations -> Request ListWorkerConfigurations
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListWorkerConfigurations
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListWorkerConfigurations)))
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 [WorkerConfigurationSummary]
-> Int
-> ListWorkerConfigurationsResponse
ListWorkerConfigurationsResponse'
            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
"workerConfigurations"
                            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 ListWorkerConfigurations where
  hashWithSalt :: Int -> ListWorkerConfigurations -> Int
hashWithSalt Int
_salt ListWorkerConfigurations' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Text
$sel:maxResults:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Natural
..} =
    Int
_salt
      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 ListWorkerConfigurations where
  rnf :: ListWorkerConfigurations -> ()
rnf ListWorkerConfigurations' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Text
$sel:maxResults:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Natural
..} =
    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 ListWorkerConfigurations where
  toHeaders :: ListWorkerConfigurations -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToPath ListWorkerConfigurations where
  toPath :: ListWorkerConfigurations -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/v1/worker-configurations"

instance Data.ToQuery ListWorkerConfigurations where
  toQuery :: ListWorkerConfigurations -> QueryString
toQuery ListWorkerConfigurations' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Text
$sel:maxResults:ListWorkerConfigurations' :: ListWorkerConfigurations -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken
      ]

-- | /See:/ 'newListWorkerConfigurationsResponse' smart constructor.
data ListWorkerConfigurationsResponse = ListWorkerConfigurationsResponse'
  { -- | If the response of a ListWorkerConfigurations operation is truncated, it
    -- will include a NextToken. Send this NextToken in a subsequent request to
    -- continue listing from where the previous operation left off.
    ListWorkerConfigurationsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An array of worker configuration descriptions.
    ListWorkerConfigurationsResponse
-> Maybe [WorkerConfigurationSummary]
workerConfigurations :: Prelude.Maybe [WorkerConfigurationSummary],
    -- | The response's http status code.
    ListWorkerConfigurationsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListWorkerConfigurationsResponse
-> ListWorkerConfigurationsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListWorkerConfigurationsResponse
-> ListWorkerConfigurationsResponse -> Bool
$c/= :: ListWorkerConfigurationsResponse
-> ListWorkerConfigurationsResponse -> Bool
== :: ListWorkerConfigurationsResponse
-> ListWorkerConfigurationsResponse -> Bool
$c== :: ListWorkerConfigurationsResponse
-> ListWorkerConfigurationsResponse -> Bool
Prelude.Eq, ReadPrec [ListWorkerConfigurationsResponse]
ReadPrec ListWorkerConfigurationsResponse
Int -> ReadS ListWorkerConfigurationsResponse
ReadS [ListWorkerConfigurationsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListWorkerConfigurationsResponse]
$creadListPrec :: ReadPrec [ListWorkerConfigurationsResponse]
readPrec :: ReadPrec ListWorkerConfigurationsResponse
$creadPrec :: ReadPrec ListWorkerConfigurationsResponse
readList :: ReadS [ListWorkerConfigurationsResponse]
$creadList :: ReadS [ListWorkerConfigurationsResponse]
readsPrec :: Int -> ReadS ListWorkerConfigurationsResponse
$creadsPrec :: Int -> ReadS ListWorkerConfigurationsResponse
Prelude.Read, Int -> ListWorkerConfigurationsResponse -> ShowS
[ListWorkerConfigurationsResponse] -> ShowS
ListWorkerConfigurationsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListWorkerConfigurationsResponse] -> ShowS
$cshowList :: [ListWorkerConfigurationsResponse] -> ShowS
show :: ListWorkerConfigurationsResponse -> String
$cshow :: ListWorkerConfigurationsResponse -> String
showsPrec :: Int -> ListWorkerConfigurationsResponse -> ShowS
$cshowsPrec :: Int -> ListWorkerConfigurationsResponse -> ShowS
Prelude.Show, forall x.
Rep ListWorkerConfigurationsResponse x
-> ListWorkerConfigurationsResponse
forall x.
ListWorkerConfigurationsResponse
-> Rep ListWorkerConfigurationsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListWorkerConfigurationsResponse x
-> ListWorkerConfigurationsResponse
$cfrom :: forall x.
ListWorkerConfigurationsResponse
-> Rep ListWorkerConfigurationsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListWorkerConfigurationsResponse' 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', 'listWorkerConfigurationsResponse_nextToken' - If the response of a ListWorkerConfigurations operation is truncated, it
-- will include a NextToken. Send this NextToken in a subsequent request to
-- continue listing from where the previous operation left off.
--
-- 'workerConfigurations', 'listWorkerConfigurationsResponse_workerConfigurations' - An array of worker configuration descriptions.
--
-- 'httpStatus', 'listWorkerConfigurationsResponse_httpStatus' - The response's http status code.
newListWorkerConfigurationsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListWorkerConfigurationsResponse
newListWorkerConfigurationsResponse :: Int -> ListWorkerConfigurationsResponse
newListWorkerConfigurationsResponse Int
pHttpStatus_ =
  ListWorkerConfigurationsResponse'
    { $sel:nextToken:ListWorkerConfigurationsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:workerConfigurations:ListWorkerConfigurationsResponse' :: Maybe [WorkerConfigurationSummary]
workerConfigurations = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListWorkerConfigurationsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If the response of a ListWorkerConfigurations operation is truncated, it
-- will include a NextToken. Send this NextToken in a subsequent request to
-- continue listing from where the previous operation left off.
listWorkerConfigurationsResponse_nextToken :: Lens.Lens' ListWorkerConfigurationsResponse (Prelude.Maybe Prelude.Text)
listWorkerConfigurationsResponse_nextToken :: Lens' ListWorkerConfigurationsResponse (Maybe Text)
listWorkerConfigurationsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkerConfigurationsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListWorkerConfigurationsResponse' :: ListWorkerConfigurationsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListWorkerConfigurationsResponse
s@ListWorkerConfigurationsResponse' {} Maybe Text
a -> ListWorkerConfigurationsResponse
s {$sel:nextToken:ListWorkerConfigurationsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListWorkerConfigurationsResponse)

-- | An array of worker configuration descriptions.
listWorkerConfigurationsResponse_workerConfigurations :: Lens.Lens' ListWorkerConfigurationsResponse (Prelude.Maybe [WorkerConfigurationSummary])
listWorkerConfigurationsResponse_workerConfigurations :: Lens'
  ListWorkerConfigurationsResponse
  (Maybe [WorkerConfigurationSummary])
listWorkerConfigurationsResponse_workerConfigurations = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkerConfigurationsResponse' {Maybe [WorkerConfigurationSummary]
workerConfigurations :: Maybe [WorkerConfigurationSummary]
$sel:workerConfigurations:ListWorkerConfigurationsResponse' :: ListWorkerConfigurationsResponse
-> Maybe [WorkerConfigurationSummary]
workerConfigurations} -> Maybe [WorkerConfigurationSummary]
workerConfigurations) (\s :: ListWorkerConfigurationsResponse
s@ListWorkerConfigurationsResponse' {} Maybe [WorkerConfigurationSummary]
a -> ListWorkerConfigurationsResponse
s {$sel:workerConfigurations:ListWorkerConfigurationsResponse' :: Maybe [WorkerConfigurationSummary]
workerConfigurations = Maybe [WorkerConfigurationSummary]
a} :: ListWorkerConfigurationsResponse) 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.
listWorkerConfigurationsResponse_httpStatus :: Lens.Lens' ListWorkerConfigurationsResponse Prelude.Int
listWorkerConfigurationsResponse_httpStatus :: Lens' ListWorkerConfigurationsResponse Int
listWorkerConfigurationsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkerConfigurationsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListWorkerConfigurationsResponse' :: ListWorkerConfigurationsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListWorkerConfigurationsResponse
s@ListWorkerConfigurationsResponse' {} Int
a -> ListWorkerConfigurationsResponse
s {$sel:httpStatus:ListWorkerConfigurationsResponse' :: Int
httpStatus = Int
a} :: ListWorkerConfigurationsResponse)

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