{-# 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.LakeFormation.SearchDatabasesByLFTags
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- This operation allows a search on @DATABASE@ resources by
-- @TagCondition@. This operation is used by admins who want to grant user
-- permissions on certain @TagConditions@. Before making a grant, the admin
-- can use @SearchDatabasesByTags@ to find all resources where the given
-- @TagConditions@ are valid to verify whether the returned resources can
-- be shared.
--
-- This operation returns paginated results.
module Amazonka.LakeFormation.SearchDatabasesByLFTags
  ( -- * Creating a Request
    SearchDatabasesByLFTags (..),
    newSearchDatabasesByLFTags,

    -- * Request Lenses
    searchDatabasesByLFTags_catalogId,
    searchDatabasesByLFTags_maxResults,
    searchDatabasesByLFTags_nextToken,
    searchDatabasesByLFTags_expression,

    -- * Destructuring the Response
    SearchDatabasesByLFTagsResponse (..),
    newSearchDatabasesByLFTagsResponse,

    -- * Response Lenses
    searchDatabasesByLFTagsResponse_databaseList,
    searchDatabasesByLFTagsResponse_nextToken,
    searchDatabasesByLFTagsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newSearchDatabasesByLFTags' smart constructor.
data SearchDatabasesByLFTags = SearchDatabasesByLFTags'
  { -- | The identifier for the Data Catalog. By default, the account ID. The
    -- Data Catalog is the persistent metadata store. It contains database
    -- definitions, table definitions, and other control information to manage
    -- your Lake Formation environment.
    SearchDatabasesByLFTags -> Maybe Text
catalogId :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of results to return.
    SearchDatabasesByLFTags -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | A continuation token, if this is not the first call to retrieve this
    -- list.
    SearchDatabasesByLFTags -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of conditions (@LFTag@ structures) to search for in database
    -- resources.
    SearchDatabasesByLFTags -> NonEmpty LFTag
expression :: Prelude.NonEmpty LFTag
  }
  deriving (SearchDatabasesByLFTags -> SearchDatabasesByLFTags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchDatabasesByLFTags -> SearchDatabasesByLFTags -> Bool
$c/= :: SearchDatabasesByLFTags -> SearchDatabasesByLFTags -> Bool
== :: SearchDatabasesByLFTags -> SearchDatabasesByLFTags -> Bool
$c== :: SearchDatabasesByLFTags -> SearchDatabasesByLFTags -> Bool
Prelude.Eq, ReadPrec [SearchDatabasesByLFTags]
ReadPrec SearchDatabasesByLFTags
Int -> ReadS SearchDatabasesByLFTags
ReadS [SearchDatabasesByLFTags]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchDatabasesByLFTags]
$creadListPrec :: ReadPrec [SearchDatabasesByLFTags]
readPrec :: ReadPrec SearchDatabasesByLFTags
$creadPrec :: ReadPrec SearchDatabasesByLFTags
readList :: ReadS [SearchDatabasesByLFTags]
$creadList :: ReadS [SearchDatabasesByLFTags]
readsPrec :: Int -> ReadS SearchDatabasesByLFTags
$creadsPrec :: Int -> ReadS SearchDatabasesByLFTags
Prelude.Read, Int -> SearchDatabasesByLFTags -> ShowS
[SearchDatabasesByLFTags] -> ShowS
SearchDatabasesByLFTags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchDatabasesByLFTags] -> ShowS
$cshowList :: [SearchDatabasesByLFTags] -> ShowS
show :: SearchDatabasesByLFTags -> String
$cshow :: SearchDatabasesByLFTags -> String
showsPrec :: Int -> SearchDatabasesByLFTags -> ShowS
$cshowsPrec :: Int -> SearchDatabasesByLFTags -> ShowS
Prelude.Show, forall x. Rep SearchDatabasesByLFTags x -> SearchDatabasesByLFTags
forall x. SearchDatabasesByLFTags -> Rep SearchDatabasesByLFTags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SearchDatabasesByLFTags x -> SearchDatabasesByLFTags
$cfrom :: forall x. SearchDatabasesByLFTags -> Rep SearchDatabasesByLFTags x
Prelude.Generic)

-- |
-- Create a value of 'SearchDatabasesByLFTags' 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:
--
-- 'catalogId', 'searchDatabasesByLFTags_catalogId' - The identifier for the Data Catalog. By default, the account ID. The
-- Data Catalog is the persistent metadata store. It contains database
-- definitions, table definitions, and other control information to manage
-- your Lake Formation environment.
--
-- 'maxResults', 'searchDatabasesByLFTags_maxResults' - The maximum number of results to return.
--
-- 'nextToken', 'searchDatabasesByLFTags_nextToken' - A continuation token, if this is not the first call to retrieve this
-- list.
--
-- 'expression', 'searchDatabasesByLFTags_expression' - A list of conditions (@LFTag@ structures) to search for in database
-- resources.
newSearchDatabasesByLFTags ::
  -- | 'expression'
  Prelude.NonEmpty LFTag ->
  SearchDatabasesByLFTags
newSearchDatabasesByLFTags :: NonEmpty LFTag -> SearchDatabasesByLFTags
newSearchDatabasesByLFTags NonEmpty LFTag
pExpression_ =
  SearchDatabasesByLFTags'
    { $sel:catalogId:SearchDatabasesByLFTags' :: Maybe Text
catalogId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:SearchDatabasesByLFTags' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:SearchDatabasesByLFTags' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:expression:SearchDatabasesByLFTags' :: NonEmpty LFTag
expression = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty LFTag
pExpression_
    }

-- | The identifier for the Data Catalog. By default, the account ID. The
-- Data Catalog is the persistent metadata store. It contains database
-- definitions, table definitions, and other control information to manage
-- your Lake Formation environment.
searchDatabasesByLFTags_catalogId :: Lens.Lens' SearchDatabasesByLFTags (Prelude.Maybe Prelude.Text)
searchDatabasesByLFTags_catalogId :: Lens' SearchDatabasesByLFTags (Maybe Text)
searchDatabasesByLFTags_catalogId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchDatabasesByLFTags' {Maybe Text
catalogId :: Maybe Text
$sel:catalogId:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Text
catalogId} -> Maybe Text
catalogId) (\s :: SearchDatabasesByLFTags
s@SearchDatabasesByLFTags' {} Maybe Text
a -> SearchDatabasesByLFTags
s {$sel:catalogId:SearchDatabasesByLFTags' :: Maybe Text
catalogId = Maybe Text
a} :: SearchDatabasesByLFTags)

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

-- | A continuation token, if this is not the first call to retrieve this
-- list.
searchDatabasesByLFTags_nextToken :: Lens.Lens' SearchDatabasesByLFTags (Prelude.Maybe Prelude.Text)
searchDatabasesByLFTags_nextToken :: Lens' SearchDatabasesByLFTags (Maybe Text)
searchDatabasesByLFTags_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchDatabasesByLFTags' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: SearchDatabasesByLFTags
s@SearchDatabasesByLFTags' {} Maybe Text
a -> SearchDatabasesByLFTags
s {$sel:nextToken:SearchDatabasesByLFTags' :: Maybe Text
nextToken = Maybe Text
a} :: SearchDatabasesByLFTags)

-- | A list of conditions (@LFTag@ structures) to search for in database
-- resources.
searchDatabasesByLFTags_expression :: Lens.Lens' SearchDatabasesByLFTags (Prelude.NonEmpty LFTag)
searchDatabasesByLFTags_expression :: Lens' SearchDatabasesByLFTags (NonEmpty LFTag)
searchDatabasesByLFTags_expression = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchDatabasesByLFTags' {NonEmpty LFTag
expression :: NonEmpty LFTag
$sel:expression:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> NonEmpty LFTag
expression} -> NonEmpty LFTag
expression) (\s :: SearchDatabasesByLFTags
s@SearchDatabasesByLFTags' {} NonEmpty LFTag
a -> SearchDatabasesByLFTags
s {$sel:expression:SearchDatabasesByLFTags' :: NonEmpty LFTag
expression = NonEmpty LFTag
a} :: SearchDatabasesByLFTags) 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 Core.AWSPager SearchDatabasesByLFTags where
  page :: SearchDatabasesByLFTags
-> AWSResponse SearchDatabasesByLFTags
-> Maybe SearchDatabasesByLFTags
page SearchDatabasesByLFTags
rq AWSResponse SearchDatabasesByLFTags
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse SearchDatabasesByLFTags
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchDatabasesByLFTagsResponse (Maybe Text)
searchDatabasesByLFTagsResponse_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 SearchDatabasesByLFTags
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchDatabasesByLFTagsResponse (Maybe [TaggedDatabase])
searchDatabasesByLFTagsResponse_databaseList
            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.$ SearchDatabasesByLFTags
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' SearchDatabasesByLFTags (Maybe Text)
searchDatabasesByLFTags_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse SearchDatabasesByLFTags
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchDatabasesByLFTagsResponse (Maybe Text)
searchDatabasesByLFTagsResponse_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 SearchDatabasesByLFTags where
  type
    AWSResponse SearchDatabasesByLFTags =
      SearchDatabasesByLFTagsResponse
  request :: (Service -> Service)
-> SearchDatabasesByLFTags -> Request SearchDatabasesByLFTags
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 SearchDatabasesByLFTags
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse SearchDatabasesByLFTags)))
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 [TaggedDatabase]
-> Maybe Text -> Int -> SearchDatabasesByLFTagsResponse
SearchDatabasesByLFTagsResponse'
            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
"DatabaseList" 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 SearchDatabasesByLFTags where
  hashWithSalt :: Int -> SearchDatabasesByLFTags -> Int
hashWithSalt Int
_salt SearchDatabasesByLFTags' {Maybe Natural
Maybe Text
NonEmpty LFTag
expression :: NonEmpty LFTag
nextToken :: Maybe Text
maxResults :: Maybe Natural
catalogId :: Maybe Text
$sel:expression:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> NonEmpty LFTag
$sel:nextToken:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Text
$sel:maxResults:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Natural
$sel:catalogId:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
catalogId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty LFTag
expression

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

instance Data.ToHeaders SearchDatabasesByLFTags where
  toHeaders :: SearchDatabasesByLFTags -> 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 SearchDatabasesByLFTags where
  toJSON :: SearchDatabasesByLFTags -> Value
toJSON SearchDatabasesByLFTags' {Maybe Natural
Maybe Text
NonEmpty LFTag
expression :: NonEmpty LFTag
nextToken :: Maybe Text
maxResults :: Maybe Natural
catalogId :: Maybe Text
$sel:expression:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> NonEmpty LFTag
$sel:nextToken:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Text
$sel:maxResults:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Natural
$sel:catalogId:SearchDatabasesByLFTags' :: SearchDatabasesByLFTags -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CatalogId" 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
catalogId,
            (Key
"MaxResults" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxResults,
            (Key
"NextToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken,
            forall a. a -> Maybe a
Prelude.Just (Key
"Expression" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty LFTag
expression)
          ]
      )

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

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

-- | /See:/ 'newSearchDatabasesByLFTagsResponse' smart constructor.
data SearchDatabasesByLFTagsResponse = SearchDatabasesByLFTagsResponse'
  { -- | A list of databases that meet the LF-tag conditions.
    SearchDatabasesByLFTagsResponse -> Maybe [TaggedDatabase]
databaseList :: Prelude.Maybe [TaggedDatabase],
    -- | A continuation token, present if the current list segment is not the
    -- last.
    SearchDatabasesByLFTagsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    SearchDatabasesByLFTagsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (SearchDatabasesByLFTagsResponse
-> SearchDatabasesByLFTagsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchDatabasesByLFTagsResponse
-> SearchDatabasesByLFTagsResponse -> Bool
$c/= :: SearchDatabasesByLFTagsResponse
-> SearchDatabasesByLFTagsResponse -> Bool
== :: SearchDatabasesByLFTagsResponse
-> SearchDatabasesByLFTagsResponse -> Bool
$c== :: SearchDatabasesByLFTagsResponse
-> SearchDatabasesByLFTagsResponse -> Bool
Prelude.Eq, ReadPrec [SearchDatabasesByLFTagsResponse]
ReadPrec SearchDatabasesByLFTagsResponse
Int -> ReadS SearchDatabasesByLFTagsResponse
ReadS [SearchDatabasesByLFTagsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchDatabasesByLFTagsResponse]
$creadListPrec :: ReadPrec [SearchDatabasesByLFTagsResponse]
readPrec :: ReadPrec SearchDatabasesByLFTagsResponse
$creadPrec :: ReadPrec SearchDatabasesByLFTagsResponse
readList :: ReadS [SearchDatabasesByLFTagsResponse]
$creadList :: ReadS [SearchDatabasesByLFTagsResponse]
readsPrec :: Int -> ReadS SearchDatabasesByLFTagsResponse
$creadsPrec :: Int -> ReadS SearchDatabasesByLFTagsResponse
Prelude.Read, Int -> SearchDatabasesByLFTagsResponse -> ShowS
[SearchDatabasesByLFTagsResponse] -> ShowS
SearchDatabasesByLFTagsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchDatabasesByLFTagsResponse] -> ShowS
$cshowList :: [SearchDatabasesByLFTagsResponse] -> ShowS
show :: SearchDatabasesByLFTagsResponse -> String
$cshow :: SearchDatabasesByLFTagsResponse -> String
showsPrec :: Int -> SearchDatabasesByLFTagsResponse -> ShowS
$cshowsPrec :: Int -> SearchDatabasesByLFTagsResponse -> ShowS
Prelude.Show, forall x.
Rep SearchDatabasesByLFTagsResponse x
-> SearchDatabasesByLFTagsResponse
forall x.
SearchDatabasesByLFTagsResponse
-> Rep SearchDatabasesByLFTagsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep SearchDatabasesByLFTagsResponse x
-> SearchDatabasesByLFTagsResponse
$cfrom :: forall x.
SearchDatabasesByLFTagsResponse
-> Rep SearchDatabasesByLFTagsResponse x
Prelude.Generic)

-- |
-- Create a value of 'SearchDatabasesByLFTagsResponse' 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:
--
-- 'databaseList', 'searchDatabasesByLFTagsResponse_databaseList' - A list of databases that meet the LF-tag conditions.
--
-- 'nextToken', 'searchDatabasesByLFTagsResponse_nextToken' - A continuation token, present if the current list segment is not the
-- last.
--
-- 'httpStatus', 'searchDatabasesByLFTagsResponse_httpStatus' - The response's http status code.
newSearchDatabasesByLFTagsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SearchDatabasesByLFTagsResponse
newSearchDatabasesByLFTagsResponse :: Int -> SearchDatabasesByLFTagsResponse
newSearchDatabasesByLFTagsResponse Int
pHttpStatus_ =
  SearchDatabasesByLFTagsResponse'
    { $sel:databaseList:SearchDatabasesByLFTagsResponse' :: Maybe [TaggedDatabase]
databaseList =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:SearchDatabasesByLFTagsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SearchDatabasesByLFTagsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of databases that meet the LF-tag conditions.
searchDatabasesByLFTagsResponse_databaseList :: Lens.Lens' SearchDatabasesByLFTagsResponse (Prelude.Maybe [TaggedDatabase])
searchDatabasesByLFTagsResponse_databaseList :: Lens' SearchDatabasesByLFTagsResponse (Maybe [TaggedDatabase])
searchDatabasesByLFTagsResponse_databaseList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchDatabasesByLFTagsResponse' {Maybe [TaggedDatabase]
databaseList :: Maybe [TaggedDatabase]
$sel:databaseList:SearchDatabasesByLFTagsResponse' :: SearchDatabasesByLFTagsResponse -> Maybe [TaggedDatabase]
databaseList} -> Maybe [TaggedDatabase]
databaseList) (\s :: SearchDatabasesByLFTagsResponse
s@SearchDatabasesByLFTagsResponse' {} Maybe [TaggedDatabase]
a -> SearchDatabasesByLFTagsResponse
s {$sel:databaseList:SearchDatabasesByLFTagsResponse' :: Maybe [TaggedDatabase]
databaseList = Maybe [TaggedDatabase]
a} :: SearchDatabasesByLFTagsResponse) 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 continuation token, present if the current list segment is not the
-- last.
searchDatabasesByLFTagsResponse_nextToken :: Lens.Lens' SearchDatabasesByLFTagsResponse (Prelude.Maybe Prelude.Text)
searchDatabasesByLFTagsResponse_nextToken :: Lens' SearchDatabasesByLFTagsResponse (Maybe Text)
searchDatabasesByLFTagsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchDatabasesByLFTagsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:SearchDatabasesByLFTagsResponse' :: SearchDatabasesByLFTagsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: SearchDatabasesByLFTagsResponse
s@SearchDatabasesByLFTagsResponse' {} Maybe Text
a -> SearchDatabasesByLFTagsResponse
s {$sel:nextToken:SearchDatabasesByLFTagsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: SearchDatabasesByLFTagsResponse)

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

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