{-# 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.ControlTower.ListEnabledControls
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists the controls enabled by AWS Control Tower on the specified
-- organizational unit and the accounts it contains.
--
-- This operation returns paginated results.
module Amazonka.ControlTower.ListEnabledControls
  ( -- * Creating a Request
    ListEnabledControls (..),
    newListEnabledControls,

    -- * Request Lenses
    listEnabledControls_maxResults,
    listEnabledControls_nextToken,
    listEnabledControls_targetIdentifier,

    -- * Destructuring the Response
    ListEnabledControlsResponse (..),
    newListEnabledControlsResponse,

    -- * Response Lenses
    listEnabledControlsResponse_nextToken,
    listEnabledControlsResponse_httpStatus,
    listEnabledControlsResponse_enabledControls,
  )
where

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

-- | /See:/ 'newListEnabledControls' smart constructor.
data ListEnabledControls = ListEnabledControls'
  { -- | How many results to return per API call.
    ListEnabledControls -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token to continue the list from a previous API call with the same
    -- parameters.
    ListEnabledControls -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the organizational unit.
    ListEnabledControls -> Text
targetIdentifier :: Prelude.Text
  }
  deriving (ListEnabledControls -> ListEnabledControls -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListEnabledControls -> ListEnabledControls -> Bool
$c/= :: ListEnabledControls -> ListEnabledControls -> Bool
== :: ListEnabledControls -> ListEnabledControls -> Bool
$c== :: ListEnabledControls -> ListEnabledControls -> Bool
Prelude.Eq, ReadPrec [ListEnabledControls]
ReadPrec ListEnabledControls
Int -> ReadS ListEnabledControls
ReadS [ListEnabledControls]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListEnabledControls]
$creadListPrec :: ReadPrec [ListEnabledControls]
readPrec :: ReadPrec ListEnabledControls
$creadPrec :: ReadPrec ListEnabledControls
readList :: ReadS [ListEnabledControls]
$creadList :: ReadS [ListEnabledControls]
readsPrec :: Int -> ReadS ListEnabledControls
$creadsPrec :: Int -> ReadS ListEnabledControls
Prelude.Read, Int -> ListEnabledControls -> ShowS
[ListEnabledControls] -> ShowS
ListEnabledControls -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListEnabledControls] -> ShowS
$cshowList :: [ListEnabledControls] -> ShowS
show :: ListEnabledControls -> String
$cshow :: ListEnabledControls -> String
showsPrec :: Int -> ListEnabledControls -> ShowS
$cshowsPrec :: Int -> ListEnabledControls -> ShowS
Prelude.Show, forall x. Rep ListEnabledControls x -> ListEnabledControls
forall x. ListEnabledControls -> Rep ListEnabledControls x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListEnabledControls x -> ListEnabledControls
$cfrom :: forall x. ListEnabledControls -> Rep ListEnabledControls x
Prelude.Generic)

-- |
-- Create a value of 'ListEnabledControls' 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', 'listEnabledControls_maxResults' - How many results to return per API call.
--
-- 'nextToken', 'listEnabledControls_nextToken' - The token to continue the list from a previous API call with the same
-- parameters.
--
-- 'targetIdentifier', 'listEnabledControls_targetIdentifier' - The ARN of the organizational unit.
newListEnabledControls ::
  -- | 'targetIdentifier'
  Prelude.Text ->
  ListEnabledControls
newListEnabledControls :: Text -> ListEnabledControls
newListEnabledControls Text
pTargetIdentifier_ =
  ListEnabledControls'
    { $sel:maxResults:ListEnabledControls' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListEnabledControls' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:targetIdentifier:ListEnabledControls' :: Text
targetIdentifier = Text
pTargetIdentifier_
    }

-- | How many results to return per API call.
listEnabledControls_maxResults :: Lens.Lens' ListEnabledControls (Prelude.Maybe Prelude.Natural)
listEnabledControls_maxResults :: Lens' ListEnabledControls (Maybe Natural)
listEnabledControls_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListEnabledControls' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListEnabledControls' :: ListEnabledControls -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListEnabledControls
s@ListEnabledControls' {} Maybe Natural
a -> ListEnabledControls
s {$sel:maxResults:ListEnabledControls' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListEnabledControls)

-- | The token to continue the list from a previous API call with the same
-- parameters.
listEnabledControls_nextToken :: Lens.Lens' ListEnabledControls (Prelude.Maybe Prelude.Text)
listEnabledControls_nextToken :: Lens' ListEnabledControls (Maybe Text)
listEnabledControls_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListEnabledControls' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListEnabledControls' :: ListEnabledControls -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListEnabledControls
s@ListEnabledControls' {} Maybe Text
a -> ListEnabledControls
s {$sel:nextToken:ListEnabledControls' :: Maybe Text
nextToken = Maybe Text
a} :: ListEnabledControls)

-- | The ARN of the organizational unit.
listEnabledControls_targetIdentifier :: Lens.Lens' ListEnabledControls Prelude.Text
listEnabledControls_targetIdentifier :: Lens' ListEnabledControls Text
listEnabledControls_targetIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListEnabledControls' {Text
targetIdentifier :: Text
$sel:targetIdentifier:ListEnabledControls' :: ListEnabledControls -> Text
targetIdentifier} -> Text
targetIdentifier) (\s :: ListEnabledControls
s@ListEnabledControls' {} Text
a -> ListEnabledControls
s {$sel:targetIdentifier:ListEnabledControls' :: Text
targetIdentifier = Text
a} :: ListEnabledControls)

instance Core.AWSPager ListEnabledControls where
  page :: ListEnabledControls
-> AWSResponse ListEnabledControls -> Maybe ListEnabledControls
page ListEnabledControls
rq AWSResponse ListEnabledControls
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListEnabledControls
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListEnabledControlsResponse (Maybe Text)
listEnabledControlsResponse_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 ListEnabledControls
rs
            forall s a. s -> Getting a s a -> a
Lens.^. Lens' ListEnabledControlsResponse [EnabledControlSummary]
listEnabledControlsResponse_enabledControls
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListEnabledControls
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListEnabledControls (Maybe Text)
listEnabledControls_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListEnabledControls
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListEnabledControlsResponse (Maybe Text)
listEnabledControlsResponse_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 ListEnabledControls where
  type
    AWSResponse ListEnabledControls =
      ListEnabledControlsResponse
  request :: (Service -> Service)
-> ListEnabledControls -> Request ListEnabledControls
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 ListEnabledControls
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListEnabledControls)))
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
-> Int -> [EnabledControlSummary] -> ListEnabledControlsResponse
ListEnabledControlsResponse'
            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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            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
"enabledControls"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable ListEnabledControls where
  hashWithSalt :: Int -> ListEnabledControls -> Int
hashWithSalt Int
_salt ListEnabledControls' {Maybe Natural
Maybe Text
Text
targetIdentifier :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:targetIdentifier:ListEnabledControls' :: ListEnabledControls -> Text
$sel:nextToken:ListEnabledControls' :: ListEnabledControls -> Maybe Text
$sel:maxResults:ListEnabledControls' :: ListEnabledControls -> 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
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
targetIdentifier

instance Prelude.NFData ListEnabledControls where
  rnf :: ListEnabledControls -> ()
rnf ListEnabledControls' {Maybe Natural
Maybe Text
Text
targetIdentifier :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:targetIdentifier:ListEnabledControls' :: ListEnabledControls -> Text
$sel:nextToken:ListEnabledControls' :: ListEnabledControls -> Maybe Text
$sel:maxResults:ListEnabledControls' :: ListEnabledControls -> 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
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
targetIdentifier

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

instance Data.ToPath ListEnabledControls where
  toPath :: ListEnabledControls -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/list-enabled-controls"

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

-- | /See:/ 'newListEnabledControlsResponse' smart constructor.
data ListEnabledControlsResponse = ListEnabledControlsResponse'
  { -- | Retrieves the next page of results. If the string is empty, the current
    -- response is the end of the results.
    ListEnabledControlsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListEnabledControlsResponse -> Int
httpStatus :: Prelude.Int,
    -- | Lists the controls enabled by AWS Control Tower on the specified
    -- organizational unit and the accounts it contains.
    ListEnabledControlsResponse -> [EnabledControlSummary]
enabledControls :: [EnabledControlSummary]
  }
  deriving (ListEnabledControlsResponse -> ListEnabledControlsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListEnabledControlsResponse -> ListEnabledControlsResponse -> Bool
$c/= :: ListEnabledControlsResponse -> ListEnabledControlsResponse -> Bool
== :: ListEnabledControlsResponse -> ListEnabledControlsResponse -> Bool
$c== :: ListEnabledControlsResponse -> ListEnabledControlsResponse -> Bool
Prelude.Eq, ReadPrec [ListEnabledControlsResponse]
ReadPrec ListEnabledControlsResponse
Int -> ReadS ListEnabledControlsResponse
ReadS [ListEnabledControlsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListEnabledControlsResponse]
$creadListPrec :: ReadPrec [ListEnabledControlsResponse]
readPrec :: ReadPrec ListEnabledControlsResponse
$creadPrec :: ReadPrec ListEnabledControlsResponse
readList :: ReadS [ListEnabledControlsResponse]
$creadList :: ReadS [ListEnabledControlsResponse]
readsPrec :: Int -> ReadS ListEnabledControlsResponse
$creadsPrec :: Int -> ReadS ListEnabledControlsResponse
Prelude.Read, Int -> ListEnabledControlsResponse -> ShowS
[ListEnabledControlsResponse] -> ShowS
ListEnabledControlsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListEnabledControlsResponse] -> ShowS
$cshowList :: [ListEnabledControlsResponse] -> ShowS
show :: ListEnabledControlsResponse -> String
$cshow :: ListEnabledControlsResponse -> String
showsPrec :: Int -> ListEnabledControlsResponse -> ShowS
$cshowsPrec :: Int -> ListEnabledControlsResponse -> ShowS
Prelude.Show, forall x.
Rep ListEnabledControlsResponse x -> ListEnabledControlsResponse
forall x.
ListEnabledControlsResponse -> Rep ListEnabledControlsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListEnabledControlsResponse x -> ListEnabledControlsResponse
$cfrom :: forall x.
ListEnabledControlsResponse -> Rep ListEnabledControlsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListEnabledControlsResponse' 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', 'listEnabledControlsResponse_nextToken' - Retrieves the next page of results. If the string is empty, the current
-- response is the end of the results.
--
-- 'httpStatus', 'listEnabledControlsResponse_httpStatus' - The response's http status code.
--
-- 'enabledControls', 'listEnabledControlsResponse_enabledControls' - Lists the controls enabled by AWS Control Tower on the specified
-- organizational unit and the accounts it contains.
newListEnabledControlsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListEnabledControlsResponse
newListEnabledControlsResponse :: Int -> ListEnabledControlsResponse
newListEnabledControlsResponse Int
pHttpStatus_ =
  ListEnabledControlsResponse'
    { $sel:nextToken:ListEnabledControlsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListEnabledControlsResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:enabledControls:ListEnabledControlsResponse' :: [EnabledControlSummary]
enabledControls = forall a. Monoid a => a
Prelude.mempty
    }

-- | Retrieves the next page of results. If the string is empty, the current
-- response is the end of the results.
listEnabledControlsResponse_nextToken :: Lens.Lens' ListEnabledControlsResponse (Prelude.Maybe Prelude.Text)
listEnabledControlsResponse_nextToken :: Lens' ListEnabledControlsResponse (Maybe Text)
listEnabledControlsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListEnabledControlsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListEnabledControlsResponse' :: ListEnabledControlsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListEnabledControlsResponse
s@ListEnabledControlsResponse' {} Maybe Text
a -> ListEnabledControlsResponse
s {$sel:nextToken:ListEnabledControlsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListEnabledControlsResponse)

-- | The response's http status code.
listEnabledControlsResponse_httpStatus :: Lens.Lens' ListEnabledControlsResponse Prelude.Int
listEnabledControlsResponse_httpStatus :: Lens' ListEnabledControlsResponse Int
listEnabledControlsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListEnabledControlsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListEnabledControlsResponse' :: ListEnabledControlsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListEnabledControlsResponse
s@ListEnabledControlsResponse' {} Int
a -> ListEnabledControlsResponse
s {$sel:httpStatus:ListEnabledControlsResponse' :: Int
httpStatus = Int
a} :: ListEnabledControlsResponse)

-- | Lists the controls enabled by AWS Control Tower on the specified
-- organizational unit and the accounts it contains.
listEnabledControlsResponse_enabledControls :: Lens.Lens' ListEnabledControlsResponse [EnabledControlSummary]
listEnabledControlsResponse_enabledControls :: Lens' ListEnabledControlsResponse [EnabledControlSummary]
listEnabledControlsResponse_enabledControls = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListEnabledControlsResponse' {[EnabledControlSummary]
enabledControls :: [EnabledControlSummary]
$sel:enabledControls:ListEnabledControlsResponse' :: ListEnabledControlsResponse -> [EnabledControlSummary]
enabledControls} -> [EnabledControlSummary]
enabledControls) (\s :: ListEnabledControlsResponse
s@ListEnabledControlsResponse' {} [EnabledControlSummary]
a -> ListEnabledControlsResponse
s {$sel:enabledControls:ListEnabledControlsResponse' :: [EnabledControlSummary]
enabledControls = [EnabledControlSummary]
a} :: ListEnabledControlsResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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