{-# 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.Inspector2.ListCoverage
-- 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 coverage details for you environment.
--
-- This operation returns paginated results.
module Amazonka.Inspector2.ListCoverage
  ( -- * Creating a Request
    ListCoverage (..),
    newListCoverage,

    -- * Request Lenses
    listCoverage_filterCriteria,
    listCoverage_maxResults,
    listCoverage_nextToken,

    -- * Destructuring the Response
    ListCoverageResponse (..),
    newListCoverageResponse,

    -- * Response Lenses
    listCoverageResponse_coveredResources,
    listCoverageResponse_nextToken,
    listCoverageResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListCoverage' smart constructor.
data ListCoverage = ListCoverage'
  { -- | An object that contains details on the filters to apply to the coverage
    -- data for your environment.
    ListCoverage -> Maybe CoverageFilterCriteria
filterCriteria :: Prelude.Maybe CoverageFilterCriteria,
    -- | The maximum number of results to return in the response.
    ListCoverage -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | A token to use for paginating results that are returned in the response.
    -- Set the value of this parameter to null for the first request to a list
    -- action. For subsequent calls, use the @NextToken@ value returned from
    -- the previous request to continue listing results after the first page.
    ListCoverage -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListCoverage -> ListCoverage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListCoverage -> ListCoverage -> Bool
$c/= :: ListCoverage -> ListCoverage -> Bool
== :: ListCoverage -> ListCoverage -> Bool
$c== :: ListCoverage -> ListCoverage -> Bool
Prelude.Eq, ReadPrec [ListCoverage]
ReadPrec ListCoverage
Int -> ReadS ListCoverage
ReadS [ListCoverage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListCoverage]
$creadListPrec :: ReadPrec [ListCoverage]
readPrec :: ReadPrec ListCoverage
$creadPrec :: ReadPrec ListCoverage
readList :: ReadS [ListCoverage]
$creadList :: ReadS [ListCoverage]
readsPrec :: Int -> ReadS ListCoverage
$creadsPrec :: Int -> ReadS ListCoverage
Prelude.Read, Int -> ListCoverage -> ShowS
[ListCoverage] -> ShowS
ListCoverage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListCoverage] -> ShowS
$cshowList :: [ListCoverage] -> ShowS
show :: ListCoverage -> String
$cshow :: ListCoverage -> String
showsPrec :: Int -> ListCoverage -> ShowS
$cshowsPrec :: Int -> ListCoverage -> ShowS
Prelude.Show, forall x. Rep ListCoverage x -> ListCoverage
forall x. ListCoverage -> Rep ListCoverage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListCoverage x -> ListCoverage
$cfrom :: forall x. ListCoverage -> Rep ListCoverage x
Prelude.Generic)

-- |
-- Create a value of 'ListCoverage' 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:
--
-- 'filterCriteria', 'listCoverage_filterCriteria' - An object that contains details on the filters to apply to the coverage
-- data for your environment.
--
-- 'maxResults', 'listCoverage_maxResults' - The maximum number of results to return in the response.
--
-- 'nextToken', 'listCoverage_nextToken' - A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
newListCoverage ::
  ListCoverage
newListCoverage :: ListCoverage
newListCoverage =
  ListCoverage'
    { $sel:filterCriteria:ListCoverage' :: Maybe CoverageFilterCriteria
filterCriteria = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListCoverage' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListCoverage' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | An object that contains details on the filters to apply to the coverage
-- data for your environment.
listCoverage_filterCriteria :: Lens.Lens' ListCoverage (Prelude.Maybe CoverageFilterCriteria)
listCoverage_filterCriteria :: Lens' ListCoverage (Maybe CoverageFilterCriteria)
listCoverage_filterCriteria = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListCoverage' {Maybe CoverageFilterCriteria
filterCriteria :: Maybe CoverageFilterCriteria
$sel:filterCriteria:ListCoverage' :: ListCoverage -> Maybe CoverageFilterCriteria
filterCriteria} -> Maybe CoverageFilterCriteria
filterCriteria) (\s :: ListCoverage
s@ListCoverage' {} Maybe CoverageFilterCriteria
a -> ListCoverage
s {$sel:filterCriteria:ListCoverage' :: Maybe CoverageFilterCriteria
filterCriteria = Maybe CoverageFilterCriteria
a} :: ListCoverage)

-- | The maximum number of results to return in the response.
listCoverage_maxResults :: Lens.Lens' ListCoverage (Prelude.Maybe Prelude.Natural)
listCoverage_maxResults :: Lens' ListCoverage (Maybe Natural)
listCoverage_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListCoverage' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListCoverage' :: ListCoverage -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListCoverage
s@ListCoverage' {} Maybe Natural
a -> ListCoverage
s {$sel:maxResults:ListCoverage' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListCoverage)

-- | A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
listCoverage_nextToken :: Lens.Lens' ListCoverage (Prelude.Maybe Prelude.Text)
listCoverage_nextToken :: Lens' ListCoverage (Maybe Text)
listCoverage_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListCoverage' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListCoverage' :: ListCoverage -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListCoverage
s@ListCoverage' {} Maybe Text
a -> ListCoverage
s {$sel:nextToken:ListCoverage' :: Maybe Text
nextToken = Maybe Text
a} :: ListCoverage)

instance Core.AWSPager ListCoverage where
  page :: ListCoverage -> AWSResponse ListCoverage -> Maybe ListCoverage
page ListCoverage
rq AWSResponse ListCoverage
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListCoverage
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListCoverageResponse (Maybe Text)
listCoverageResponse_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 ListCoverage
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListCoverageResponse (Maybe [CoveredResource])
listCoverageResponse_coveredResources
            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.$ ListCoverage
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListCoverage (Maybe Text)
listCoverage_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListCoverage
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListCoverageResponse (Maybe Text)
listCoverageResponse_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 ListCoverage where
  type AWSResponse ListCoverage = ListCoverageResponse
  request :: (Service -> Service) -> ListCoverage -> Request ListCoverage
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 ListCoverage
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListCoverage)))
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 [CoveredResource]
-> Maybe Text -> Int -> ListCoverageResponse
ListCoverageResponse'
            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
"coveredResources"
                            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 ListCoverage where
  hashWithSalt :: Int -> ListCoverage -> Int
hashWithSalt Int
_salt ListCoverage' {Maybe Natural
Maybe Text
Maybe CoverageFilterCriteria
nextToken :: Maybe Text
maxResults :: Maybe Natural
filterCriteria :: Maybe CoverageFilterCriteria
$sel:nextToken:ListCoverage' :: ListCoverage -> Maybe Text
$sel:maxResults:ListCoverage' :: ListCoverage -> Maybe Natural
$sel:filterCriteria:ListCoverage' :: ListCoverage -> Maybe CoverageFilterCriteria
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CoverageFilterCriteria
filterCriteria
      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 ListCoverage where
  rnf :: ListCoverage -> ()
rnf ListCoverage' {Maybe Natural
Maybe Text
Maybe CoverageFilterCriteria
nextToken :: Maybe Text
maxResults :: Maybe Natural
filterCriteria :: Maybe CoverageFilterCriteria
$sel:nextToken:ListCoverage' :: ListCoverage -> Maybe Text
$sel:maxResults:ListCoverage' :: ListCoverage -> Maybe Natural
$sel:filterCriteria:ListCoverage' :: ListCoverage -> Maybe CoverageFilterCriteria
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CoverageFilterCriteria
filterCriteria
      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

instance Data.ToHeaders ListCoverage where
  toHeaders :: ListCoverage -> 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 ListCoverage where
  toJSON :: ListCoverage -> Value
toJSON ListCoverage' {Maybe Natural
Maybe Text
Maybe CoverageFilterCriteria
nextToken :: Maybe Text
maxResults :: Maybe Natural
filterCriteria :: Maybe CoverageFilterCriteria
$sel:nextToken:ListCoverage' :: ListCoverage -> Maybe Text
$sel:maxResults:ListCoverage' :: ListCoverage -> Maybe Natural
$sel:filterCriteria:ListCoverage' :: ListCoverage -> Maybe CoverageFilterCriteria
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"filterCriteria" 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 CoverageFilterCriteria
filterCriteria,
            (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
          ]
      )

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

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

-- | /See:/ 'newListCoverageResponse' smart constructor.
data ListCoverageResponse = ListCoverageResponse'
  { -- | An object that contains details on the covered resources in your
    -- environment.
    ListCoverageResponse -> Maybe [CoveredResource]
coveredResources :: Prelude.Maybe [CoveredResource],
    -- | A token to use for paginating results that are returned in the response.
    -- Set the value of this parameter to null for the first request to a list
    -- action. For subsequent calls, use the @NextToken@ value returned from
    -- the previous request to continue listing results after the first page.
    ListCoverageResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListCoverageResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListCoverageResponse -> ListCoverageResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListCoverageResponse -> ListCoverageResponse -> Bool
$c/= :: ListCoverageResponse -> ListCoverageResponse -> Bool
== :: ListCoverageResponse -> ListCoverageResponse -> Bool
$c== :: ListCoverageResponse -> ListCoverageResponse -> Bool
Prelude.Eq, ReadPrec [ListCoverageResponse]
ReadPrec ListCoverageResponse
Int -> ReadS ListCoverageResponse
ReadS [ListCoverageResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListCoverageResponse]
$creadListPrec :: ReadPrec [ListCoverageResponse]
readPrec :: ReadPrec ListCoverageResponse
$creadPrec :: ReadPrec ListCoverageResponse
readList :: ReadS [ListCoverageResponse]
$creadList :: ReadS [ListCoverageResponse]
readsPrec :: Int -> ReadS ListCoverageResponse
$creadsPrec :: Int -> ReadS ListCoverageResponse
Prelude.Read, Int -> ListCoverageResponse -> ShowS
[ListCoverageResponse] -> ShowS
ListCoverageResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListCoverageResponse] -> ShowS
$cshowList :: [ListCoverageResponse] -> ShowS
show :: ListCoverageResponse -> String
$cshow :: ListCoverageResponse -> String
showsPrec :: Int -> ListCoverageResponse -> ShowS
$cshowsPrec :: Int -> ListCoverageResponse -> ShowS
Prelude.Show, forall x. Rep ListCoverageResponse x -> ListCoverageResponse
forall x. ListCoverageResponse -> Rep ListCoverageResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListCoverageResponse x -> ListCoverageResponse
$cfrom :: forall x. ListCoverageResponse -> Rep ListCoverageResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListCoverageResponse' 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:
--
-- 'coveredResources', 'listCoverageResponse_coveredResources' - An object that contains details on the covered resources in your
-- environment.
--
-- 'nextToken', 'listCoverageResponse_nextToken' - A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
--
-- 'httpStatus', 'listCoverageResponse_httpStatus' - The response's http status code.
newListCoverageResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListCoverageResponse
newListCoverageResponse :: Int -> ListCoverageResponse
newListCoverageResponse Int
pHttpStatus_ =
  ListCoverageResponse'
    { $sel:coveredResources:ListCoverageResponse' :: Maybe [CoveredResource]
coveredResources =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListCoverageResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListCoverageResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | An object that contains details on the covered resources in your
-- environment.
listCoverageResponse_coveredResources :: Lens.Lens' ListCoverageResponse (Prelude.Maybe [CoveredResource])
listCoverageResponse_coveredResources :: Lens' ListCoverageResponse (Maybe [CoveredResource])
listCoverageResponse_coveredResources = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListCoverageResponse' {Maybe [CoveredResource]
coveredResources :: Maybe [CoveredResource]
$sel:coveredResources:ListCoverageResponse' :: ListCoverageResponse -> Maybe [CoveredResource]
coveredResources} -> Maybe [CoveredResource]
coveredResources) (\s :: ListCoverageResponse
s@ListCoverageResponse' {} Maybe [CoveredResource]
a -> ListCoverageResponse
s {$sel:coveredResources:ListCoverageResponse' :: Maybe [CoveredResource]
coveredResources = Maybe [CoveredResource]
a} :: ListCoverageResponse) 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

-- | A token to use for paginating results that are returned in the response.
-- Set the value of this parameter to null for the first request to a list
-- action. For subsequent calls, use the @NextToken@ value returned from
-- the previous request to continue listing results after the first page.
listCoverageResponse_nextToken :: Lens.Lens' ListCoverageResponse (Prelude.Maybe Prelude.Text)
listCoverageResponse_nextToken :: Lens' ListCoverageResponse (Maybe Text)
listCoverageResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListCoverageResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListCoverageResponse' :: ListCoverageResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListCoverageResponse
s@ListCoverageResponse' {} Maybe Text
a -> ListCoverageResponse
s {$sel:nextToken:ListCoverageResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListCoverageResponse)

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

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