{-# 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.Config.DescribeConfigRules
-- 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 details about your Config rules.
--
-- This operation returns paginated results.
module Amazonka.Config.DescribeConfigRules
  ( -- * Creating a Request
    DescribeConfigRules (..),
    newDescribeConfigRules,

    -- * Request Lenses
    describeConfigRules_configRuleNames,
    describeConfigRules_filters,
    describeConfigRules_nextToken,

    -- * Destructuring the Response
    DescribeConfigRulesResponse (..),
    newDescribeConfigRulesResponse,

    -- * Response Lenses
    describeConfigRulesResponse_configRules,
    describeConfigRulesResponse_nextToken,
    describeConfigRulesResponse_httpStatus,
  )
where

import Amazonka.Config.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:/ 'newDescribeConfigRules' smart constructor.
data DescribeConfigRules = DescribeConfigRules'
  { -- | The names of the Config rules for which you want details. If you do not
    -- specify any names, Config returns details for all your rules.
    DescribeConfigRules -> Maybe [Text]
configRuleNames :: Prelude.Maybe [Prelude.Text],
    -- | Returns a list of Detecive or Proactive Config rules. By default, this
    -- API returns an unfiltered list.
    DescribeConfigRules -> Maybe DescribeConfigRulesFilters
filters :: Prelude.Maybe DescribeConfigRulesFilters,
    -- | The @nextToken@ string returned on a previous page that you use to get
    -- the next page of results in a paginated response.
    DescribeConfigRules -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (DescribeConfigRules -> DescribeConfigRules -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeConfigRules -> DescribeConfigRules -> Bool
$c/= :: DescribeConfigRules -> DescribeConfigRules -> Bool
== :: DescribeConfigRules -> DescribeConfigRules -> Bool
$c== :: DescribeConfigRules -> DescribeConfigRules -> Bool
Prelude.Eq, ReadPrec [DescribeConfigRules]
ReadPrec DescribeConfigRules
Int -> ReadS DescribeConfigRules
ReadS [DescribeConfigRules]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeConfigRules]
$creadListPrec :: ReadPrec [DescribeConfigRules]
readPrec :: ReadPrec DescribeConfigRules
$creadPrec :: ReadPrec DescribeConfigRules
readList :: ReadS [DescribeConfigRules]
$creadList :: ReadS [DescribeConfigRules]
readsPrec :: Int -> ReadS DescribeConfigRules
$creadsPrec :: Int -> ReadS DescribeConfigRules
Prelude.Read, Int -> DescribeConfigRules -> ShowS
[DescribeConfigRules] -> ShowS
DescribeConfigRules -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeConfigRules] -> ShowS
$cshowList :: [DescribeConfigRules] -> ShowS
show :: DescribeConfigRules -> String
$cshow :: DescribeConfigRules -> String
showsPrec :: Int -> DescribeConfigRules -> ShowS
$cshowsPrec :: Int -> DescribeConfigRules -> ShowS
Prelude.Show, forall x. Rep DescribeConfigRules x -> DescribeConfigRules
forall x. DescribeConfigRules -> Rep DescribeConfigRules x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeConfigRules x -> DescribeConfigRules
$cfrom :: forall x. DescribeConfigRules -> Rep DescribeConfigRules x
Prelude.Generic)

-- |
-- Create a value of 'DescribeConfigRules' 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:
--
-- 'configRuleNames', 'describeConfigRules_configRuleNames' - The names of the Config rules for which you want details. If you do not
-- specify any names, Config returns details for all your rules.
--
-- 'filters', 'describeConfigRules_filters' - Returns a list of Detecive or Proactive Config rules. By default, this
-- API returns an unfiltered list.
--
-- 'nextToken', 'describeConfigRules_nextToken' - The @nextToken@ string returned on a previous page that you use to get
-- the next page of results in a paginated response.
newDescribeConfigRules ::
  DescribeConfigRules
newDescribeConfigRules :: DescribeConfigRules
newDescribeConfigRules =
  DescribeConfigRules'
    { $sel:configRuleNames:DescribeConfigRules' :: Maybe [Text]
configRuleNames =
        forall a. Maybe a
Prelude.Nothing,
      $sel:filters:DescribeConfigRules' :: Maybe DescribeConfigRulesFilters
filters = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeConfigRules' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The names of the Config rules for which you want details. If you do not
-- specify any names, Config returns details for all your rules.
describeConfigRules_configRuleNames :: Lens.Lens' DescribeConfigRules (Prelude.Maybe [Prelude.Text])
describeConfigRules_configRuleNames :: Lens' DescribeConfigRules (Maybe [Text])
describeConfigRules_configRuleNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeConfigRules' {Maybe [Text]
configRuleNames :: Maybe [Text]
$sel:configRuleNames:DescribeConfigRules' :: DescribeConfigRules -> Maybe [Text]
configRuleNames} -> Maybe [Text]
configRuleNames) (\s :: DescribeConfigRules
s@DescribeConfigRules' {} Maybe [Text]
a -> DescribeConfigRules
s {$sel:configRuleNames:DescribeConfigRules' :: Maybe [Text]
configRuleNames = Maybe [Text]
a} :: DescribeConfigRules) 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

-- | Returns a list of Detecive or Proactive Config rules. By default, this
-- API returns an unfiltered list.
describeConfigRules_filters :: Lens.Lens' DescribeConfigRules (Prelude.Maybe DescribeConfigRulesFilters)
describeConfigRules_filters :: Lens' DescribeConfigRules (Maybe DescribeConfigRulesFilters)
describeConfigRules_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeConfigRules' {Maybe DescribeConfigRulesFilters
filters :: Maybe DescribeConfigRulesFilters
$sel:filters:DescribeConfigRules' :: DescribeConfigRules -> Maybe DescribeConfigRulesFilters
filters} -> Maybe DescribeConfigRulesFilters
filters) (\s :: DescribeConfigRules
s@DescribeConfigRules' {} Maybe DescribeConfigRulesFilters
a -> DescribeConfigRules
s {$sel:filters:DescribeConfigRules' :: Maybe DescribeConfigRulesFilters
filters = Maybe DescribeConfigRulesFilters
a} :: DescribeConfigRules)

-- | The @nextToken@ string returned on a previous page that you use to get
-- the next page of results in a paginated response.
describeConfigRules_nextToken :: Lens.Lens' DescribeConfigRules (Prelude.Maybe Prelude.Text)
describeConfigRules_nextToken :: Lens' DescribeConfigRules (Maybe Text)
describeConfigRules_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeConfigRules' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeConfigRules' :: DescribeConfigRules -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeConfigRules
s@DescribeConfigRules' {} Maybe Text
a -> DescribeConfigRules
s {$sel:nextToken:DescribeConfigRules' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeConfigRules)

instance Core.AWSPager DescribeConfigRules where
  page :: DescribeConfigRules
-> AWSResponse DescribeConfigRules -> Maybe DescribeConfigRules
page DescribeConfigRules
rq AWSResponse DescribeConfigRules
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse DescribeConfigRules
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeConfigRulesResponse (Maybe Text)
describeConfigRulesResponse_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 DescribeConfigRules
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeConfigRulesResponse (Maybe [ConfigRule])
describeConfigRulesResponse_configRules
            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.$ DescribeConfigRules
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' DescribeConfigRules (Maybe Text)
describeConfigRules_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse DescribeConfigRules
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' DescribeConfigRulesResponse (Maybe Text)
describeConfigRulesResponse_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 DescribeConfigRules where
  type
    AWSResponse DescribeConfigRules =
      DescribeConfigRulesResponse
  request :: (Service -> Service)
-> DescribeConfigRules -> Request DescribeConfigRules
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 DescribeConfigRules
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeConfigRules)))
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 [ConfigRule]
-> Maybe Text -> Int -> DescribeConfigRulesResponse
DescribeConfigRulesResponse'
            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
"ConfigRules" 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.<*> (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))
      )

instance Prelude.Hashable DescribeConfigRules where
  hashWithSalt :: Int -> DescribeConfigRules -> Int
hashWithSalt Int
_salt DescribeConfigRules' {Maybe [Text]
Maybe Text
Maybe DescribeConfigRulesFilters
nextToken :: Maybe Text
filters :: Maybe DescribeConfigRulesFilters
configRuleNames :: Maybe [Text]
$sel:nextToken:DescribeConfigRules' :: DescribeConfigRules -> Maybe Text
$sel:filters:DescribeConfigRules' :: DescribeConfigRules -> Maybe DescribeConfigRulesFilters
$sel:configRuleNames:DescribeConfigRules' :: DescribeConfigRules -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
configRuleNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DescribeConfigRulesFilters
filters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData DescribeConfigRules where
  rnf :: DescribeConfigRules -> ()
rnf DescribeConfigRules' {Maybe [Text]
Maybe Text
Maybe DescribeConfigRulesFilters
nextToken :: Maybe Text
filters :: Maybe DescribeConfigRulesFilters
configRuleNames :: Maybe [Text]
$sel:nextToken:DescribeConfigRules' :: DescribeConfigRules -> Maybe Text
$sel:filters:DescribeConfigRules' :: DescribeConfigRules -> Maybe DescribeConfigRulesFilters
$sel:configRuleNames:DescribeConfigRules' :: DescribeConfigRules -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
configRuleNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DescribeConfigRulesFilters
filters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

instance Data.ToHeaders DescribeConfigRules where
  toHeaders :: DescribeConfigRules -> 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
"StarlingDoveService.DescribeConfigRules" ::
                          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 DescribeConfigRules where
  toJSON :: DescribeConfigRules -> Value
toJSON DescribeConfigRules' {Maybe [Text]
Maybe Text
Maybe DescribeConfigRulesFilters
nextToken :: Maybe Text
filters :: Maybe DescribeConfigRulesFilters
configRuleNames :: Maybe [Text]
$sel:nextToken:DescribeConfigRules' :: DescribeConfigRules -> Maybe Text
$sel:filters:DescribeConfigRules' :: DescribeConfigRules -> Maybe DescribeConfigRulesFilters
$sel:configRuleNames:DescribeConfigRules' :: DescribeConfigRules -> Maybe [Text]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ConfigRuleNames" 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]
configRuleNames,
            (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 DescribeConfigRulesFilters
filters,
            (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 DescribeConfigRules where
  toPath :: DescribeConfigRules -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- |
--
-- /See:/ 'newDescribeConfigRulesResponse' smart constructor.
data DescribeConfigRulesResponse = DescribeConfigRulesResponse'
  { -- | The details about your Config rules.
    DescribeConfigRulesResponse -> Maybe [ConfigRule]
configRules :: Prelude.Maybe [ConfigRule],
    -- | The string that you use in a subsequent request to get the next page of
    -- results in a paginated response.
    DescribeConfigRulesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    DescribeConfigRulesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeConfigRulesResponse -> DescribeConfigRulesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeConfigRulesResponse -> DescribeConfigRulesResponse -> Bool
$c/= :: DescribeConfigRulesResponse -> DescribeConfigRulesResponse -> Bool
== :: DescribeConfigRulesResponse -> DescribeConfigRulesResponse -> Bool
$c== :: DescribeConfigRulesResponse -> DescribeConfigRulesResponse -> Bool
Prelude.Eq, ReadPrec [DescribeConfigRulesResponse]
ReadPrec DescribeConfigRulesResponse
Int -> ReadS DescribeConfigRulesResponse
ReadS [DescribeConfigRulesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeConfigRulesResponse]
$creadListPrec :: ReadPrec [DescribeConfigRulesResponse]
readPrec :: ReadPrec DescribeConfigRulesResponse
$creadPrec :: ReadPrec DescribeConfigRulesResponse
readList :: ReadS [DescribeConfigRulesResponse]
$creadList :: ReadS [DescribeConfigRulesResponse]
readsPrec :: Int -> ReadS DescribeConfigRulesResponse
$creadsPrec :: Int -> ReadS DescribeConfigRulesResponse
Prelude.Read, Int -> DescribeConfigRulesResponse -> ShowS
[DescribeConfigRulesResponse] -> ShowS
DescribeConfigRulesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeConfigRulesResponse] -> ShowS
$cshowList :: [DescribeConfigRulesResponse] -> ShowS
show :: DescribeConfigRulesResponse -> String
$cshow :: DescribeConfigRulesResponse -> String
showsPrec :: Int -> DescribeConfigRulesResponse -> ShowS
$cshowsPrec :: Int -> DescribeConfigRulesResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeConfigRulesResponse x -> DescribeConfigRulesResponse
forall x.
DescribeConfigRulesResponse -> Rep DescribeConfigRulesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeConfigRulesResponse x -> DescribeConfigRulesResponse
$cfrom :: forall x.
DescribeConfigRulesResponse -> Rep DescribeConfigRulesResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeConfigRulesResponse' 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:
--
-- 'configRules', 'describeConfigRulesResponse_configRules' - The details about your Config rules.
--
-- 'nextToken', 'describeConfigRulesResponse_nextToken' - The string that you use in a subsequent request to get the next page of
-- results in a paginated response.
--
-- 'httpStatus', 'describeConfigRulesResponse_httpStatus' - The response's http status code.
newDescribeConfigRulesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeConfigRulesResponse
newDescribeConfigRulesResponse :: Int -> DescribeConfigRulesResponse
newDescribeConfigRulesResponse Int
pHttpStatus_ =
  DescribeConfigRulesResponse'
    { $sel:configRules:DescribeConfigRulesResponse' :: Maybe [ConfigRule]
configRules =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeConfigRulesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeConfigRulesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The details about your Config rules.
describeConfigRulesResponse_configRules :: Lens.Lens' DescribeConfigRulesResponse (Prelude.Maybe [ConfigRule])
describeConfigRulesResponse_configRules :: Lens' DescribeConfigRulesResponse (Maybe [ConfigRule])
describeConfigRulesResponse_configRules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeConfigRulesResponse' {Maybe [ConfigRule]
configRules :: Maybe [ConfigRule]
$sel:configRules:DescribeConfigRulesResponse' :: DescribeConfigRulesResponse -> Maybe [ConfigRule]
configRules} -> Maybe [ConfigRule]
configRules) (\s :: DescribeConfigRulesResponse
s@DescribeConfigRulesResponse' {} Maybe [ConfigRule]
a -> DescribeConfigRulesResponse
s {$sel:configRules:DescribeConfigRulesResponse' :: Maybe [ConfigRule]
configRules = Maybe [ConfigRule]
a} :: DescribeConfigRulesResponse) 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 string that you use in a subsequent request to get the next page of
-- results in a paginated response.
describeConfigRulesResponse_nextToken :: Lens.Lens' DescribeConfigRulesResponse (Prelude.Maybe Prelude.Text)
describeConfigRulesResponse_nextToken :: Lens' DescribeConfigRulesResponse (Maybe Text)
describeConfigRulesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeConfigRulesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeConfigRulesResponse' :: DescribeConfigRulesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeConfigRulesResponse
s@DescribeConfigRulesResponse' {} Maybe Text
a -> DescribeConfigRulesResponse
s {$sel:nextToken:DescribeConfigRulesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeConfigRulesResponse)

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

instance Prelude.NFData DescribeConfigRulesResponse where
  rnf :: DescribeConfigRulesResponse -> ()
rnf DescribeConfigRulesResponse' {Int
Maybe [ConfigRule]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
configRules :: Maybe [ConfigRule]
$sel:httpStatus:DescribeConfigRulesResponse' :: DescribeConfigRulesResponse -> Int
$sel:nextToken:DescribeConfigRulesResponse' :: DescribeConfigRulesResponse -> Maybe Text
$sel:configRules:DescribeConfigRulesResponse' :: DescribeConfigRulesResponse -> Maybe [ConfigRule]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ConfigRule]
configRules
      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 Int
httpStatus