{-# 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.GetDatalakeStatus
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves a snapshot of the current Region, including whether Amazon
-- Security Lake is enabled for those accounts and which sources Security
-- Lake is collecting data from.
--
-- This operation returns paginated results.
module Amazonka.SecurityLake.GetDatalakeStatus
  ( -- * Creating a Request
    GetDatalakeStatus (..),
    newGetDatalakeStatus,

    -- * Request Lenses
    getDatalakeStatus_accountSet,
    getDatalakeStatus_maxAccountResults,
    getDatalakeStatus_nextToken,

    -- * Destructuring the Response
    GetDatalakeStatusResponse (..),
    newGetDatalakeStatusResponse,

    -- * Response Lenses
    getDatalakeStatusResponse_nextToken,
    getDatalakeStatusResponse_httpStatus,
    getDatalakeStatusResponse_accountSourcesList,
  )
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:/ 'newGetDatalakeStatus' smart constructor.
data GetDatalakeStatus = GetDatalakeStatus'
  { -- | The Amazon Web Services account ID for which a static snapshot of the
    -- current Amazon Web Services Region, including enabled accounts and log
    -- sources, is retrieved.
    GetDatalakeStatus -> Maybe [Text]
accountSet :: Prelude.Maybe [Prelude.Text],
    -- | The maximum limit of accounts for which the static snapshot of the
    -- current Region, including enabled accounts and log sources, is
    -- retrieved.
    GetDatalakeStatus -> Maybe Int
maxAccountResults :: Prelude.Maybe Prelude.Int,
    -- | Lists 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.
    GetDatalakeStatus -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (GetDatalakeStatus -> GetDatalakeStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetDatalakeStatus -> GetDatalakeStatus -> Bool
$c/= :: GetDatalakeStatus -> GetDatalakeStatus -> Bool
== :: GetDatalakeStatus -> GetDatalakeStatus -> Bool
$c== :: GetDatalakeStatus -> GetDatalakeStatus -> Bool
Prelude.Eq, ReadPrec [GetDatalakeStatus]
ReadPrec GetDatalakeStatus
Int -> ReadS GetDatalakeStatus
ReadS [GetDatalakeStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetDatalakeStatus]
$creadListPrec :: ReadPrec [GetDatalakeStatus]
readPrec :: ReadPrec GetDatalakeStatus
$creadPrec :: ReadPrec GetDatalakeStatus
readList :: ReadS [GetDatalakeStatus]
$creadList :: ReadS [GetDatalakeStatus]
readsPrec :: Int -> ReadS GetDatalakeStatus
$creadsPrec :: Int -> ReadS GetDatalakeStatus
Prelude.Read, Int -> GetDatalakeStatus -> ShowS
[GetDatalakeStatus] -> ShowS
GetDatalakeStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetDatalakeStatus] -> ShowS
$cshowList :: [GetDatalakeStatus] -> ShowS
show :: GetDatalakeStatus -> String
$cshow :: GetDatalakeStatus -> String
showsPrec :: Int -> GetDatalakeStatus -> ShowS
$cshowsPrec :: Int -> GetDatalakeStatus -> ShowS
Prelude.Show, forall x. Rep GetDatalakeStatus x -> GetDatalakeStatus
forall x. GetDatalakeStatus -> Rep GetDatalakeStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetDatalakeStatus x -> GetDatalakeStatus
$cfrom :: forall x. GetDatalakeStatus -> Rep GetDatalakeStatus x
Prelude.Generic)

-- |
-- Create a value of 'GetDatalakeStatus' 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:
--
-- 'accountSet', 'getDatalakeStatus_accountSet' - The Amazon Web Services account ID for which a static snapshot of the
-- current Amazon Web Services Region, including enabled accounts and log
-- sources, is retrieved.
--
-- 'maxAccountResults', 'getDatalakeStatus_maxAccountResults' - The maximum limit of accounts for which the static snapshot of the
-- current Region, including enabled accounts and log sources, is
-- retrieved.
--
-- 'nextToken', 'getDatalakeStatus_nextToken' - Lists 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.
newGetDatalakeStatus ::
  GetDatalakeStatus
newGetDatalakeStatus :: GetDatalakeStatus
newGetDatalakeStatus =
  GetDatalakeStatus'
    { $sel:accountSet:GetDatalakeStatus' :: Maybe [Text]
accountSet = forall a. Maybe a
Prelude.Nothing,
      $sel:maxAccountResults:GetDatalakeStatus' :: Maybe Int
maxAccountResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:GetDatalakeStatus' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The Amazon Web Services account ID for which a static snapshot of the
-- current Amazon Web Services Region, including enabled accounts and log
-- sources, is retrieved.
getDatalakeStatus_accountSet :: Lens.Lens' GetDatalakeStatus (Prelude.Maybe [Prelude.Text])
getDatalakeStatus_accountSet :: Lens' GetDatalakeStatus (Maybe [Text])
getDatalakeStatus_accountSet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDatalakeStatus' {Maybe [Text]
accountSet :: Maybe [Text]
$sel:accountSet:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe [Text]
accountSet} -> Maybe [Text]
accountSet) (\s :: GetDatalakeStatus
s@GetDatalakeStatus' {} Maybe [Text]
a -> GetDatalakeStatus
s {$sel:accountSet:GetDatalakeStatus' :: Maybe [Text]
accountSet = Maybe [Text]
a} :: GetDatalakeStatus) 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 maximum limit of accounts for which the static snapshot of the
-- current Region, including enabled accounts and log sources, is
-- retrieved.
getDatalakeStatus_maxAccountResults :: Lens.Lens' GetDatalakeStatus (Prelude.Maybe Prelude.Int)
getDatalakeStatus_maxAccountResults :: Lens' GetDatalakeStatus (Maybe Int)
getDatalakeStatus_maxAccountResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDatalakeStatus' {Maybe Int
maxAccountResults :: Maybe Int
$sel:maxAccountResults:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Int
maxAccountResults} -> Maybe Int
maxAccountResults) (\s :: GetDatalakeStatus
s@GetDatalakeStatus' {} Maybe Int
a -> GetDatalakeStatus
s {$sel:maxAccountResults:GetDatalakeStatus' :: Maybe Int
maxAccountResults = Maybe Int
a} :: GetDatalakeStatus)

-- | Lists 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.
getDatalakeStatus_nextToken :: Lens.Lens' GetDatalakeStatus (Prelude.Maybe Prelude.Text)
getDatalakeStatus_nextToken :: Lens' GetDatalakeStatus (Maybe Text)
getDatalakeStatus_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDatalakeStatus' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetDatalakeStatus
s@GetDatalakeStatus' {} Maybe Text
a -> GetDatalakeStatus
s {$sel:nextToken:GetDatalakeStatus' :: Maybe Text
nextToken = Maybe Text
a} :: GetDatalakeStatus)

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

instance Prelude.Hashable GetDatalakeStatus where
  hashWithSalt :: Int -> GetDatalakeStatus -> Int
hashWithSalt Int
_salt GetDatalakeStatus' {Maybe Int
Maybe [Text]
Maybe Text
nextToken :: Maybe Text
maxAccountResults :: Maybe Int
accountSet :: Maybe [Text]
$sel:nextToken:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Text
$sel:maxAccountResults:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Int
$sel:accountSet:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
accountSet
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
maxAccountResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData GetDatalakeStatus where
  rnf :: GetDatalakeStatus -> ()
rnf GetDatalakeStatus' {Maybe Int
Maybe [Text]
Maybe Text
nextToken :: Maybe Text
maxAccountResults :: Maybe Int
accountSet :: Maybe [Text]
$sel:nextToken:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Text
$sel:maxAccountResults:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Int
$sel:accountSet:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
accountSet
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxAccountResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

instance Data.ToHeaders GetDatalakeStatus where
  toHeaders :: GetDatalakeStatus -> 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 GetDatalakeStatus where
  toJSON :: GetDatalakeStatus -> Value
toJSON GetDatalakeStatus' {Maybe Int
Maybe [Text]
Maybe Text
nextToken :: Maybe Text
maxAccountResults :: Maybe Int
accountSet :: Maybe [Text]
$sel:nextToken:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Text
$sel:maxAccountResults:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe Int
$sel:accountSet:GetDatalakeStatus' :: GetDatalakeStatus -> Maybe [Text]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"accountSet" 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]
accountSet,
            (Key
"maxAccountResults" 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
maxAccountResults,
            (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 GetDatalakeStatus where
  toPath :: GetDatalakeStatus -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/v1/datalake/status"

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

-- | /See:/ 'newGetDatalakeStatusResponse' smart constructor.
data GetDatalakeStatusResponse = GetDatalakeStatusResponse'
  { -- | Lists 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.
    GetDatalakeStatusResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    GetDatalakeStatusResponse -> Int
httpStatus :: Prelude.Int,
    -- | The list of enabled accounts and enabled sources.
    GetDatalakeStatusResponse -> [AccountSources]
accountSourcesList :: [AccountSources]
  }
  deriving (GetDatalakeStatusResponse -> GetDatalakeStatusResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetDatalakeStatusResponse -> GetDatalakeStatusResponse -> Bool
$c/= :: GetDatalakeStatusResponse -> GetDatalakeStatusResponse -> Bool
== :: GetDatalakeStatusResponse -> GetDatalakeStatusResponse -> Bool
$c== :: GetDatalakeStatusResponse -> GetDatalakeStatusResponse -> Bool
Prelude.Eq, ReadPrec [GetDatalakeStatusResponse]
ReadPrec GetDatalakeStatusResponse
Int -> ReadS GetDatalakeStatusResponse
ReadS [GetDatalakeStatusResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetDatalakeStatusResponse]
$creadListPrec :: ReadPrec [GetDatalakeStatusResponse]
readPrec :: ReadPrec GetDatalakeStatusResponse
$creadPrec :: ReadPrec GetDatalakeStatusResponse
readList :: ReadS [GetDatalakeStatusResponse]
$creadList :: ReadS [GetDatalakeStatusResponse]
readsPrec :: Int -> ReadS GetDatalakeStatusResponse
$creadsPrec :: Int -> ReadS GetDatalakeStatusResponse
Prelude.Read, Int -> GetDatalakeStatusResponse -> ShowS
[GetDatalakeStatusResponse] -> ShowS
GetDatalakeStatusResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetDatalakeStatusResponse] -> ShowS
$cshowList :: [GetDatalakeStatusResponse] -> ShowS
show :: GetDatalakeStatusResponse -> String
$cshow :: GetDatalakeStatusResponse -> String
showsPrec :: Int -> GetDatalakeStatusResponse -> ShowS
$cshowsPrec :: Int -> GetDatalakeStatusResponse -> ShowS
Prelude.Show, forall x.
Rep GetDatalakeStatusResponse x -> GetDatalakeStatusResponse
forall x.
GetDatalakeStatusResponse -> Rep GetDatalakeStatusResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetDatalakeStatusResponse x -> GetDatalakeStatusResponse
$cfrom :: forall x.
GetDatalakeStatusResponse -> Rep GetDatalakeStatusResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetDatalakeStatusResponse' 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', 'getDatalakeStatusResponse_nextToken' - Lists 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', 'getDatalakeStatusResponse_httpStatus' - The response's http status code.
--
-- 'accountSourcesList', 'getDatalakeStatusResponse_accountSourcesList' - The list of enabled accounts and enabled sources.
newGetDatalakeStatusResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetDatalakeStatusResponse
newGetDatalakeStatusResponse :: Int -> GetDatalakeStatusResponse
newGetDatalakeStatusResponse Int
pHttpStatus_ =
  GetDatalakeStatusResponse'
    { $sel:nextToken:GetDatalakeStatusResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetDatalakeStatusResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:accountSourcesList:GetDatalakeStatusResponse' :: [AccountSources]
accountSourcesList = forall a. Monoid a => a
Prelude.mempty
    }

-- | Lists 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.
getDatalakeStatusResponse_nextToken :: Lens.Lens' GetDatalakeStatusResponse (Prelude.Maybe Prelude.Text)
getDatalakeStatusResponse_nextToken :: Lens' GetDatalakeStatusResponse (Maybe Text)
getDatalakeStatusResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDatalakeStatusResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetDatalakeStatusResponse' :: GetDatalakeStatusResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetDatalakeStatusResponse
s@GetDatalakeStatusResponse' {} Maybe Text
a -> GetDatalakeStatusResponse
s {$sel:nextToken:GetDatalakeStatusResponse' :: Maybe Text
nextToken = Maybe Text
a} :: GetDatalakeStatusResponse)

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

-- | The list of enabled accounts and enabled sources.
getDatalakeStatusResponse_accountSourcesList :: Lens.Lens' GetDatalakeStatusResponse [AccountSources]
getDatalakeStatusResponse_accountSourcesList :: Lens' GetDatalakeStatusResponse [AccountSources]
getDatalakeStatusResponse_accountSourcesList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetDatalakeStatusResponse' {[AccountSources]
accountSourcesList :: [AccountSources]
$sel:accountSourcesList:GetDatalakeStatusResponse' :: GetDatalakeStatusResponse -> [AccountSources]
accountSourcesList} -> [AccountSources]
accountSourcesList) (\s :: GetDatalakeStatusResponse
s@GetDatalakeStatusResponse' {} [AccountSources]
a -> GetDatalakeStatusResponse
s {$sel:accountSourcesList:GetDatalakeStatusResponse' :: [AccountSources]
accountSourcesList = [AccountSources]
a} :: GetDatalakeStatusResponse) 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 GetDatalakeStatusResponse where
  rnf :: GetDatalakeStatusResponse -> ()
rnf GetDatalakeStatusResponse' {Int
[AccountSources]
Maybe Text
accountSourcesList :: [AccountSources]
httpStatus :: Int
nextToken :: Maybe Text
$sel:accountSourcesList:GetDatalakeStatusResponse' :: GetDatalakeStatusResponse -> [AccountSources]
$sel:httpStatus:GetDatalakeStatusResponse' :: GetDatalakeStatusResponse -> Int
$sel:nextToken:GetDatalakeStatusResponse' :: GetDatalakeStatusResponse -> 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 [AccountSources]
accountSourcesList