{-# 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.SecurityLake.ListDatalakeExceptions
-- 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 Amazon Security Lake exceptions that you can use to find the
-- source of problems and fix them.
--
-- This operation returns paginated results.
module Amazonka.SecurityLake.ListDatalakeExceptions
  ( -- * Creating a Request
    ListDatalakeExceptions (..),
    newListDatalakeExceptions,

    -- * Request Lenses
    listDatalakeExceptions_maxFailures,
    listDatalakeExceptions_nextToken,
    listDatalakeExceptions_regionSet,

    -- * Destructuring the Response
    ListDatalakeExceptionsResponse (..),
    newListDatalakeExceptionsResponse,

    -- * Response Lenses
    listDatalakeExceptionsResponse_nextToken,
    listDatalakeExceptionsResponse_httpStatus,
    listDatalakeExceptionsResponse_nonRetryableFailures,
  )
where

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
import Amazonka.SecurityLake.Types

-- | /See:/ 'newListDatalakeExceptions' smart constructor.
data ListDatalakeExceptions = ListDatalakeExceptions'
  { -- | List the maximum number of failures in Security Lake.
    ListDatalakeExceptions -> Maybe Int
maxFailures :: Prelude.Maybe Prelude.Int,
    -- | List if there are more results available. The value of nextToken is a
    -- unique pagination token for each page. Repeat the call using the
    -- returned token to retrieve the next page. Keep all other arguments
    -- unchanged.
    --
    -- Each pagination token expires after 24 hours. Using an expired
    -- pagination token will return an HTTP 400 InvalidToken error.
    ListDatalakeExceptions -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | List the Amazon Web Services Regions from which exceptions are
    -- retrieved.
    ListDatalakeExceptions -> Maybe [Region]
regionSet :: Prelude.Maybe [Region]
  }
  deriving (ListDatalakeExceptions -> ListDatalakeExceptions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListDatalakeExceptions -> ListDatalakeExceptions -> Bool
$c/= :: ListDatalakeExceptions -> ListDatalakeExceptions -> Bool
== :: ListDatalakeExceptions -> ListDatalakeExceptions -> Bool
$c== :: ListDatalakeExceptions -> ListDatalakeExceptions -> Bool
Prelude.Eq, ReadPrec [ListDatalakeExceptions]
ReadPrec ListDatalakeExceptions
Int -> ReadS ListDatalakeExceptions
ReadS [ListDatalakeExceptions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListDatalakeExceptions]
$creadListPrec :: ReadPrec [ListDatalakeExceptions]
readPrec :: ReadPrec ListDatalakeExceptions
$creadPrec :: ReadPrec ListDatalakeExceptions
readList :: ReadS [ListDatalakeExceptions]
$creadList :: ReadS [ListDatalakeExceptions]
readsPrec :: Int -> ReadS ListDatalakeExceptions
$creadsPrec :: Int -> ReadS ListDatalakeExceptions
Prelude.Read, Int -> ListDatalakeExceptions -> ShowS
[ListDatalakeExceptions] -> ShowS
ListDatalakeExceptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListDatalakeExceptions] -> ShowS
$cshowList :: [ListDatalakeExceptions] -> ShowS
show :: ListDatalakeExceptions -> String
$cshow :: ListDatalakeExceptions -> String
showsPrec :: Int -> ListDatalakeExceptions -> ShowS
$cshowsPrec :: Int -> ListDatalakeExceptions -> ShowS
Prelude.Show, forall x. Rep ListDatalakeExceptions x -> ListDatalakeExceptions
forall x. ListDatalakeExceptions -> Rep ListDatalakeExceptions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListDatalakeExceptions x -> ListDatalakeExceptions
$cfrom :: forall x. ListDatalakeExceptions -> Rep ListDatalakeExceptions x
Prelude.Generic)

-- |
-- Create a value of 'ListDatalakeExceptions' 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:
--
-- 'maxFailures', 'listDatalakeExceptions_maxFailures' - List the maximum number of failures in Security Lake.
--
-- 'nextToken', 'listDatalakeExceptions_nextToken' - List if there are more results available. The value of nextToken is a
-- unique pagination token for each page. Repeat the call using the
-- returned token to retrieve the next page. Keep all other arguments
-- unchanged.
--
-- Each pagination token expires after 24 hours. Using an expired
-- pagination token will return an HTTP 400 InvalidToken error.
--
-- 'regionSet', 'listDatalakeExceptions_regionSet' - List the Amazon Web Services Regions from which exceptions are
-- retrieved.
newListDatalakeExceptions ::
  ListDatalakeExceptions
newListDatalakeExceptions :: ListDatalakeExceptions
newListDatalakeExceptions =
  ListDatalakeExceptions'
    { $sel:maxFailures:ListDatalakeExceptions' :: Maybe Int
maxFailures =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListDatalakeExceptions' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:regionSet:ListDatalakeExceptions' :: Maybe [Region]
regionSet = forall a. Maybe a
Prelude.Nothing
    }

-- | List the maximum number of failures in Security Lake.
listDatalakeExceptions_maxFailures :: Lens.Lens' ListDatalakeExceptions (Prelude.Maybe Prelude.Int)
listDatalakeExceptions_maxFailures :: Lens' ListDatalakeExceptions (Maybe Int)
listDatalakeExceptions_maxFailures = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDatalakeExceptions' {Maybe Int
maxFailures :: Maybe Int
$sel:maxFailures:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Int
maxFailures} -> Maybe Int
maxFailures) (\s :: ListDatalakeExceptions
s@ListDatalakeExceptions' {} Maybe Int
a -> ListDatalakeExceptions
s {$sel:maxFailures:ListDatalakeExceptions' :: Maybe Int
maxFailures = Maybe Int
a} :: ListDatalakeExceptions)

-- | List if there are more results available. The value of nextToken is a
-- unique pagination token for each page. Repeat the call using the
-- returned token to retrieve the next page. Keep all other arguments
-- unchanged.
--
-- Each pagination token expires after 24 hours. Using an expired
-- pagination token will return an HTTP 400 InvalidToken error.
listDatalakeExceptions_nextToken :: Lens.Lens' ListDatalakeExceptions (Prelude.Maybe Prelude.Text)
listDatalakeExceptions_nextToken :: Lens' ListDatalakeExceptions (Maybe Text)
listDatalakeExceptions_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDatalakeExceptions' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListDatalakeExceptions
s@ListDatalakeExceptions' {} Maybe Text
a -> ListDatalakeExceptions
s {$sel:nextToken:ListDatalakeExceptions' :: Maybe Text
nextToken = Maybe Text
a} :: ListDatalakeExceptions)

-- | List the Amazon Web Services Regions from which exceptions are
-- retrieved.
listDatalakeExceptions_regionSet :: Lens.Lens' ListDatalakeExceptions (Prelude.Maybe [Region])
listDatalakeExceptions_regionSet :: Lens' ListDatalakeExceptions (Maybe [Region])
listDatalakeExceptions_regionSet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDatalakeExceptions' {Maybe [Region]
regionSet :: Maybe [Region]
$sel:regionSet:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe [Region]
regionSet} -> Maybe [Region]
regionSet) (\s :: ListDatalakeExceptions
s@ListDatalakeExceptions' {} Maybe [Region]
a -> ListDatalakeExceptions
s {$sel:regionSet:ListDatalakeExceptions' :: Maybe [Region]
regionSet = Maybe [Region]
a} :: ListDatalakeExceptions) 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

instance Core.AWSPager ListDatalakeExceptions where
  page :: ListDatalakeExceptions
-> AWSResponse ListDatalakeExceptions
-> Maybe ListDatalakeExceptions
page ListDatalakeExceptions
rq AWSResponse ListDatalakeExceptions
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListDatalakeExceptions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListDatalakeExceptionsResponse (Maybe Text)
listDatalakeExceptionsResponse_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 ListDatalakeExceptions
rs
            forall s a. s -> Getting a s a -> a
Lens.^. Lens' ListDatalakeExceptionsResponse [FailuresResponse]
listDatalakeExceptionsResponse_nonRetryableFailures
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListDatalakeExceptions
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListDatalakeExceptions (Maybe Text)
listDatalakeExceptions_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListDatalakeExceptions
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListDatalakeExceptionsResponse (Maybe Text)
listDatalakeExceptionsResponse_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 ListDatalakeExceptions where
  type
    AWSResponse ListDatalakeExceptions =
      ListDatalakeExceptionsResponse
  request :: (Service -> Service)
-> ListDatalakeExceptions -> Request ListDatalakeExceptions
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 ListDatalakeExceptions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListDatalakeExceptions)))
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 -> [FailuresResponse] -> ListDatalakeExceptionsResponse
ListDatalakeExceptionsResponse'
            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
"nonRetryableFailures"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable ListDatalakeExceptions where
  hashWithSalt :: Int -> ListDatalakeExceptions -> Int
hashWithSalt Int
_salt ListDatalakeExceptions' {Maybe Int
Maybe [Region]
Maybe Text
regionSet :: Maybe [Region]
nextToken :: Maybe Text
maxFailures :: Maybe Int
$sel:regionSet:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe [Region]
$sel:nextToken:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Text
$sel:maxFailures:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
maxFailures
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Region]
regionSet

instance Prelude.NFData ListDatalakeExceptions where
  rnf :: ListDatalakeExceptions -> ()
rnf ListDatalakeExceptions' {Maybe Int
Maybe [Region]
Maybe Text
regionSet :: Maybe [Region]
nextToken :: Maybe Text
maxFailures :: Maybe Int
$sel:regionSet:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe [Region]
$sel:nextToken:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Text
$sel:maxFailures:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxFailures
      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 Maybe [Region]
regionSet

instance Data.ToHeaders ListDatalakeExceptions where
  toHeaders :: ListDatalakeExceptions -> 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 ListDatalakeExceptions where
  toJSON :: ListDatalakeExceptions -> Value
toJSON ListDatalakeExceptions' {Maybe Int
Maybe [Region]
Maybe Text
regionSet :: Maybe [Region]
nextToken :: Maybe Text
maxFailures :: Maybe Int
$sel:regionSet:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe [Region]
$sel:nextToken:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Text
$sel:maxFailures:ListDatalakeExceptions' :: ListDatalakeExceptions -> Maybe Int
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"maxFailures" 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
maxFailures,
            (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,
            (Key
"regionSet" 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 [Region]
regionSet
          ]
      )

instance Data.ToPath ListDatalakeExceptions where
  toPath :: ListDatalakeExceptions -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/v1/datalake/exceptions"

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

-- | /See:/ 'newListDatalakeExceptionsResponse' smart constructor.
data ListDatalakeExceptionsResponse = ListDatalakeExceptionsResponse'
  { -- | List if there are more results available. The value of nextToken is a
    -- unique pagination token for each page. Repeat the call using the
    -- returned token to retrieve the next page. Keep all other arguments
    -- unchanged.
    --
    -- Each pagination token expires after 24 hours. Using an expired
    -- pagination token will return an HTTP 400 InvalidToken error.
    ListDatalakeExceptionsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListDatalakeExceptionsResponse -> Int
httpStatus :: Prelude.Int,
    -- | Lists the failures that cannot be retried in the current Region.
    ListDatalakeExceptionsResponse -> [FailuresResponse]
nonRetryableFailures :: [FailuresResponse]
  }
  deriving (ListDatalakeExceptionsResponse
-> ListDatalakeExceptionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListDatalakeExceptionsResponse
-> ListDatalakeExceptionsResponse -> Bool
$c/= :: ListDatalakeExceptionsResponse
-> ListDatalakeExceptionsResponse -> Bool
== :: ListDatalakeExceptionsResponse
-> ListDatalakeExceptionsResponse -> Bool
$c== :: ListDatalakeExceptionsResponse
-> ListDatalakeExceptionsResponse -> Bool
Prelude.Eq, ReadPrec [ListDatalakeExceptionsResponse]
ReadPrec ListDatalakeExceptionsResponse
Int -> ReadS ListDatalakeExceptionsResponse
ReadS [ListDatalakeExceptionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListDatalakeExceptionsResponse]
$creadListPrec :: ReadPrec [ListDatalakeExceptionsResponse]
readPrec :: ReadPrec ListDatalakeExceptionsResponse
$creadPrec :: ReadPrec ListDatalakeExceptionsResponse
readList :: ReadS [ListDatalakeExceptionsResponse]
$creadList :: ReadS [ListDatalakeExceptionsResponse]
readsPrec :: Int -> ReadS ListDatalakeExceptionsResponse
$creadsPrec :: Int -> ReadS ListDatalakeExceptionsResponse
Prelude.Read, Int -> ListDatalakeExceptionsResponse -> ShowS
[ListDatalakeExceptionsResponse] -> ShowS
ListDatalakeExceptionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListDatalakeExceptionsResponse] -> ShowS
$cshowList :: [ListDatalakeExceptionsResponse] -> ShowS
show :: ListDatalakeExceptionsResponse -> String
$cshow :: ListDatalakeExceptionsResponse -> String
showsPrec :: Int -> ListDatalakeExceptionsResponse -> ShowS
$cshowsPrec :: Int -> ListDatalakeExceptionsResponse -> ShowS
Prelude.Show, forall x.
Rep ListDatalakeExceptionsResponse x
-> ListDatalakeExceptionsResponse
forall x.
ListDatalakeExceptionsResponse
-> Rep ListDatalakeExceptionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListDatalakeExceptionsResponse x
-> ListDatalakeExceptionsResponse
$cfrom :: forall x.
ListDatalakeExceptionsResponse
-> Rep ListDatalakeExceptionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListDatalakeExceptionsResponse' 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', 'listDatalakeExceptionsResponse_nextToken' - List if there are more results available. The value of nextToken is a
-- unique pagination token for each page. Repeat the call using the
-- returned token to retrieve the next page. Keep all other arguments
-- unchanged.
--
-- Each pagination token expires after 24 hours. Using an expired
-- pagination token will return an HTTP 400 InvalidToken error.
--
-- 'httpStatus', 'listDatalakeExceptionsResponse_httpStatus' - The response's http status code.
--
-- 'nonRetryableFailures', 'listDatalakeExceptionsResponse_nonRetryableFailures' - Lists the failures that cannot be retried in the current Region.
newListDatalakeExceptionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListDatalakeExceptionsResponse
newListDatalakeExceptionsResponse :: Int -> ListDatalakeExceptionsResponse
newListDatalakeExceptionsResponse Int
pHttpStatus_ =
  ListDatalakeExceptionsResponse'
    { $sel:nextToken:ListDatalakeExceptionsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListDatalakeExceptionsResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:nonRetryableFailures:ListDatalakeExceptionsResponse' :: [FailuresResponse]
nonRetryableFailures = forall a. Monoid a => a
Prelude.mempty
    }

-- | List if there are more results available. The value of nextToken is a
-- unique pagination token for each page. Repeat the call using the
-- returned token to retrieve the next page. Keep all other arguments
-- unchanged.
--
-- Each pagination token expires after 24 hours. Using an expired
-- pagination token will return an HTTP 400 InvalidToken error.
listDatalakeExceptionsResponse_nextToken :: Lens.Lens' ListDatalakeExceptionsResponse (Prelude.Maybe Prelude.Text)
listDatalakeExceptionsResponse_nextToken :: Lens' ListDatalakeExceptionsResponse (Maybe Text)
listDatalakeExceptionsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDatalakeExceptionsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListDatalakeExceptionsResponse' :: ListDatalakeExceptionsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListDatalakeExceptionsResponse
s@ListDatalakeExceptionsResponse' {} Maybe Text
a -> ListDatalakeExceptionsResponse
s {$sel:nextToken:ListDatalakeExceptionsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListDatalakeExceptionsResponse)

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

-- | Lists the failures that cannot be retried in the current Region.
listDatalakeExceptionsResponse_nonRetryableFailures :: Lens.Lens' ListDatalakeExceptionsResponse [FailuresResponse]
listDatalakeExceptionsResponse_nonRetryableFailures :: Lens' ListDatalakeExceptionsResponse [FailuresResponse]
listDatalakeExceptionsResponse_nonRetryableFailures = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDatalakeExceptionsResponse' {[FailuresResponse]
nonRetryableFailures :: [FailuresResponse]
$sel:nonRetryableFailures:ListDatalakeExceptionsResponse' :: ListDatalakeExceptionsResponse -> [FailuresResponse]
nonRetryableFailures} -> [FailuresResponse]
nonRetryableFailures) (\s :: ListDatalakeExceptionsResponse
s@ListDatalakeExceptionsResponse' {} [FailuresResponse]
a -> ListDatalakeExceptionsResponse
s {$sel:nonRetryableFailures:ListDatalakeExceptionsResponse' :: [FailuresResponse]
nonRetryableFailures = [FailuresResponse]
a} :: ListDatalakeExceptionsResponse) 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
    ListDatalakeExceptionsResponse
  where
  rnf :: ListDatalakeExceptionsResponse -> ()
rnf ListDatalakeExceptionsResponse' {Int
[FailuresResponse]
Maybe Text
nonRetryableFailures :: [FailuresResponse]
httpStatus :: Int
nextToken :: Maybe Text
$sel:nonRetryableFailures:ListDatalakeExceptionsResponse' :: ListDatalakeExceptionsResponse -> [FailuresResponse]
$sel:httpStatus:ListDatalakeExceptionsResponse' :: ListDatalakeExceptionsResponse -> Int
$sel:nextToken:ListDatalakeExceptionsResponse' :: ListDatalakeExceptionsResponse -> 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 [FailuresResponse]
nonRetryableFailures