{-# 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.Glue.GetUnfilteredTableMetadata
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- -- | Undocumented operation.
module Amazonka.Glue.GetUnfilteredTableMetadata
  ( -- * Creating a Request
    GetUnfilteredTableMetadata (..),
    newGetUnfilteredTableMetadata,

    -- * Request Lenses
    getUnfilteredTableMetadata_auditContext,
    getUnfilteredTableMetadata_catalogId,
    getUnfilteredTableMetadata_databaseName,
    getUnfilteredTableMetadata_name,
    getUnfilteredTableMetadata_supportedPermissionTypes,

    -- * Destructuring the Response
    GetUnfilteredTableMetadataResponse (..),
    newGetUnfilteredTableMetadataResponse,

    -- * Response Lenses
    getUnfilteredTableMetadataResponse_authorizedColumns,
    getUnfilteredTableMetadataResponse_cellFilters,
    getUnfilteredTableMetadataResponse_isRegisteredWithLakeFormation,
    getUnfilteredTableMetadataResponse_table,
    getUnfilteredTableMetadataResponse_httpStatus,
  )
where

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

-- | /See:/ 'newGetUnfilteredTableMetadata' smart constructor.
data GetUnfilteredTableMetadata = GetUnfilteredTableMetadata'
  { GetUnfilteredTableMetadata -> Maybe AuditContext
auditContext :: Prelude.Maybe AuditContext,
    GetUnfilteredTableMetadata -> Text
catalogId :: Prelude.Text,
    GetUnfilteredTableMetadata -> Text
databaseName :: Prelude.Text,
    GetUnfilteredTableMetadata -> Text
name :: Prelude.Text,
    GetUnfilteredTableMetadata -> NonEmpty PermissionType
supportedPermissionTypes :: Prelude.NonEmpty PermissionType
  }
  deriving (GetUnfilteredTableMetadata -> GetUnfilteredTableMetadata -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetUnfilteredTableMetadata -> GetUnfilteredTableMetadata -> Bool
$c/= :: GetUnfilteredTableMetadata -> GetUnfilteredTableMetadata -> Bool
== :: GetUnfilteredTableMetadata -> GetUnfilteredTableMetadata -> Bool
$c== :: GetUnfilteredTableMetadata -> GetUnfilteredTableMetadata -> Bool
Prelude.Eq, ReadPrec [GetUnfilteredTableMetadata]
ReadPrec GetUnfilteredTableMetadata
Int -> ReadS GetUnfilteredTableMetadata
ReadS [GetUnfilteredTableMetadata]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetUnfilteredTableMetadata]
$creadListPrec :: ReadPrec [GetUnfilteredTableMetadata]
readPrec :: ReadPrec GetUnfilteredTableMetadata
$creadPrec :: ReadPrec GetUnfilteredTableMetadata
readList :: ReadS [GetUnfilteredTableMetadata]
$creadList :: ReadS [GetUnfilteredTableMetadata]
readsPrec :: Int -> ReadS GetUnfilteredTableMetadata
$creadsPrec :: Int -> ReadS GetUnfilteredTableMetadata
Prelude.Read, Int -> GetUnfilteredTableMetadata -> ShowS
[GetUnfilteredTableMetadata] -> ShowS
GetUnfilteredTableMetadata -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetUnfilteredTableMetadata] -> ShowS
$cshowList :: [GetUnfilteredTableMetadata] -> ShowS
show :: GetUnfilteredTableMetadata -> String
$cshow :: GetUnfilteredTableMetadata -> String
showsPrec :: Int -> GetUnfilteredTableMetadata -> ShowS
$cshowsPrec :: Int -> GetUnfilteredTableMetadata -> ShowS
Prelude.Show, forall x.
Rep GetUnfilteredTableMetadata x -> GetUnfilteredTableMetadata
forall x.
GetUnfilteredTableMetadata -> Rep GetUnfilteredTableMetadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetUnfilteredTableMetadata x -> GetUnfilteredTableMetadata
$cfrom :: forall x.
GetUnfilteredTableMetadata -> Rep GetUnfilteredTableMetadata x
Prelude.Generic)

-- |
-- Create a value of 'GetUnfilteredTableMetadata' 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:
--
-- 'auditContext', 'getUnfilteredTableMetadata_auditContext' - Undocumented member.
--
-- 'catalogId', 'getUnfilteredTableMetadata_catalogId' - Undocumented member.
--
-- 'databaseName', 'getUnfilteredTableMetadata_databaseName' - Undocumented member.
--
-- 'name', 'getUnfilteredTableMetadata_name' - Undocumented member.
--
-- 'supportedPermissionTypes', 'getUnfilteredTableMetadata_supportedPermissionTypes' - Undocumented member.
newGetUnfilteredTableMetadata ::
  -- | 'catalogId'
  Prelude.Text ->
  -- | 'databaseName'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  -- | 'supportedPermissionTypes'
  Prelude.NonEmpty PermissionType ->
  GetUnfilteredTableMetadata
newGetUnfilteredTableMetadata :: Text
-> Text
-> Text
-> NonEmpty PermissionType
-> GetUnfilteredTableMetadata
newGetUnfilteredTableMetadata
  Text
pCatalogId_
  Text
pDatabaseName_
  Text
pName_
  NonEmpty PermissionType
pSupportedPermissionTypes_ =
    GetUnfilteredTableMetadata'
      { $sel:auditContext:GetUnfilteredTableMetadata' :: Maybe AuditContext
auditContext =
          forall a. Maybe a
Prelude.Nothing,
        $sel:catalogId:GetUnfilteredTableMetadata' :: Text
catalogId = Text
pCatalogId_,
        $sel:databaseName:GetUnfilteredTableMetadata' :: Text
databaseName = Text
pDatabaseName_,
        $sel:name:GetUnfilteredTableMetadata' :: Text
name = Text
pName_,
        $sel:supportedPermissionTypes:GetUnfilteredTableMetadata' :: NonEmpty PermissionType
supportedPermissionTypes =
          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 PermissionType
pSupportedPermissionTypes_
      }

-- | Undocumented member.
getUnfilteredTableMetadata_auditContext :: Lens.Lens' GetUnfilteredTableMetadata (Prelude.Maybe AuditContext)
getUnfilteredTableMetadata_auditContext :: Lens' GetUnfilteredTableMetadata (Maybe AuditContext)
getUnfilteredTableMetadata_auditContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadata' {Maybe AuditContext
auditContext :: Maybe AuditContext
$sel:auditContext:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Maybe AuditContext
auditContext} -> Maybe AuditContext
auditContext) (\s :: GetUnfilteredTableMetadata
s@GetUnfilteredTableMetadata' {} Maybe AuditContext
a -> GetUnfilteredTableMetadata
s {$sel:auditContext:GetUnfilteredTableMetadata' :: Maybe AuditContext
auditContext = Maybe AuditContext
a} :: GetUnfilteredTableMetadata)

-- | Undocumented member.
getUnfilteredTableMetadata_catalogId :: Lens.Lens' GetUnfilteredTableMetadata Prelude.Text
getUnfilteredTableMetadata_catalogId :: Lens' GetUnfilteredTableMetadata Text
getUnfilteredTableMetadata_catalogId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadata' {Text
catalogId :: Text
$sel:catalogId:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
catalogId} -> Text
catalogId) (\s :: GetUnfilteredTableMetadata
s@GetUnfilteredTableMetadata' {} Text
a -> GetUnfilteredTableMetadata
s {$sel:catalogId:GetUnfilteredTableMetadata' :: Text
catalogId = Text
a} :: GetUnfilteredTableMetadata)

-- | Undocumented member.
getUnfilteredTableMetadata_databaseName :: Lens.Lens' GetUnfilteredTableMetadata Prelude.Text
getUnfilteredTableMetadata_databaseName :: Lens' GetUnfilteredTableMetadata Text
getUnfilteredTableMetadata_databaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadata' {Text
databaseName :: Text
$sel:databaseName:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
databaseName} -> Text
databaseName) (\s :: GetUnfilteredTableMetadata
s@GetUnfilteredTableMetadata' {} Text
a -> GetUnfilteredTableMetadata
s {$sel:databaseName:GetUnfilteredTableMetadata' :: Text
databaseName = Text
a} :: GetUnfilteredTableMetadata)

-- | Undocumented member.
getUnfilteredTableMetadata_name :: Lens.Lens' GetUnfilteredTableMetadata Prelude.Text
getUnfilteredTableMetadata_name :: Lens' GetUnfilteredTableMetadata Text
getUnfilteredTableMetadata_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadata' {Text
name :: Text
$sel:name:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
name} -> Text
name) (\s :: GetUnfilteredTableMetadata
s@GetUnfilteredTableMetadata' {} Text
a -> GetUnfilteredTableMetadata
s {$sel:name:GetUnfilteredTableMetadata' :: Text
name = Text
a} :: GetUnfilteredTableMetadata)

-- | Undocumented member.
getUnfilteredTableMetadata_supportedPermissionTypes :: Lens.Lens' GetUnfilteredTableMetadata (Prelude.NonEmpty PermissionType)
getUnfilteredTableMetadata_supportedPermissionTypes :: Lens' GetUnfilteredTableMetadata (NonEmpty PermissionType)
getUnfilteredTableMetadata_supportedPermissionTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadata' {NonEmpty PermissionType
supportedPermissionTypes :: NonEmpty PermissionType
$sel:supportedPermissionTypes:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> NonEmpty PermissionType
supportedPermissionTypes} -> NonEmpty PermissionType
supportedPermissionTypes) (\s :: GetUnfilteredTableMetadata
s@GetUnfilteredTableMetadata' {} NonEmpty PermissionType
a -> GetUnfilteredTableMetadata
s {$sel:supportedPermissionTypes:GetUnfilteredTableMetadata' :: NonEmpty PermissionType
supportedPermissionTypes = NonEmpty PermissionType
a} :: GetUnfilteredTableMetadata) 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.AWSRequest GetUnfilteredTableMetadata where
  type
    AWSResponse GetUnfilteredTableMetadata =
      GetUnfilteredTableMetadataResponse
  request :: (Service -> Service)
-> GetUnfilteredTableMetadata -> Request GetUnfilteredTableMetadata
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 GetUnfilteredTableMetadata
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetUnfilteredTableMetadata)))
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]
-> Maybe [ColumnRowFilter]
-> Maybe Bool
-> Maybe Table
-> Int
-> GetUnfilteredTableMetadataResponse
GetUnfilteredTableMetadataResponse'
            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
"AuthorizedColumns"
                            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
"CellFilters" 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
"IsRegisteredWithLakeFormation")
            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
"Table")
            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 GetUnfilteredTableMetadata where
  hashWithSalt :: Int -> GetUnfilteredTableMetadata -> Int
hashWithSalt Int
_salt GetUnfilteredTableMetadata' {Maybe AuditContext
NonEmpty PermissionType
Text
supportedPermissionTypes :: NonEmpty PermissionType
name :: Text
databaseName :: Text
catalogId :: Text
auditContext :: Maybe AuditContext
$sel:supportedPermissionTypes:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> NonEmpty PermissionType
$sel:name:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:databaseName:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:catalogId:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:auditContext:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Maybe AuditContext
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AuditContext
auditContext
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
catalogId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
databaseName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty PermissionType
supportedPermissionTypes

instance Prelude.NFData GetUnfilteredTableMetadata where
  rnf :: GetUnfilteredTableMetadata -> ()
rnf GetUnfilteredTableMetadata' {Maybe AuditContext
NonEmpty PermissionType
Text
supportedPermissionTypes :: NonEmpty PermissionType
name :: Text
databaseName :: Text
catalogId :: Text
auditContext :: Maybe AuditContext
$sel:supportedPermissionTypes:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> NonEmpty PermissionType
$sel:name:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:databaseName:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:catalogId:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:auditContext:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Maybe AuditContext
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe AuditContext
auditContext
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
catalogId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
databaseName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty PermissionType
supportedPermissionTypes

instance Data.ToHeaders GetUnfilteredTableMetadata where
  toHeaders :: GetUnfilteredTableMetadata -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AWSGlue.GetUnfilteredTableMetadata" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON GetUnfilteredTableMetadata where
  toJSON :: GetUnfilteredTableMetadata -> Value
toJSON GetUnfilteredTableMetadata' {Maybe AuditContext
NonEmpty PermissionType
Text
supportedPermissionTypes :: NonEmpty PermissionType
name :: Text
databaseName :: Text
catalogId :: Text
auditContext :: Maybe AuditContext
$sel:supportedPermissionTypes:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> NonEmpty PermissionType
$sel:name:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:databaseName:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:catalogId:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Text
$sel:auditContext:GetUnfilteredTableMetadata' :: GetUnfilteredTableMetadata -> Maybe AuditContext
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AuditContext" 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 AuditContext
auditContext,
            forall a. a -> Maybe a
Prelude.Just (Key
"CatalogId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
catalogId),
            forall a. a -> Maybe a
Prelude.Just (Key
"DatabaseName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
databaseName),
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"SupportedPermissionTypes"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty PermissionType
supportedPermissionTypes
              )
          ]
      )

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

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

-- | /See:/ 'newGetUnfilteredTableMetadataResponse' smart constructor.
data GetUnfilteredTableMetadataResponse = GetUnfilteredTableMetadataResponse'
  { GetUnfilteredTableMetadataResponse -> Maybe [Text]
authorizedColumns :: Prelude.Maybe [Prelude.Text],
    GetUnfilteredTableMetadataResponse -> Maybe [ColumnRowFilter]
cellFilters :: Prelude.Maybe [ColumnRowFilter],
    GetUnfilteredTableMetadataResponse -> Maybe Bool
isRegisteredWithLakeFormation :: Prelude.Maybe Prelude.Bool,
    GetUnfilteredTableMetadataResponse -> Maybe Table
table :: Prelude.Maybe Table,
    -- | The response's http status code.
    GetUnfilteredTableMetadataResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetUnfilteredTableMetadataResponse
-> GetUnfilteredTableMetadataResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetUnfilteredTableMetadataResponse
-> GetUnfilteredTableMetadataResponse -> Bool
$c/= :: GetUnfilteredTableMetadataResponse
-> GetUnfilteredTableMetadataResponse -> Bool
== :: GetUnfilteredTableMetadataResponse
-> GetUnfilteredTableMetadataResponse -> Bool
$c== :: GetUnfilteredTableMetadataResponse
-> GetUnfilteredTableMetadataResponse -> Bool
Prelude.Eq, ReadPrec [GetUnfilteredTableMetadataResponse]
ReadPrec GetUnfilteredTableMetadataResponse
Int -> ReadS GetUnfilteredTableMetadataResponse
ReadS [GetUnfilteredTableMetadataResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetUnfilteredTableMetadataResponse]
$creadListPrec :: ReadPrec [GetUnfilteredTableMetadataResponse]
readPrec :: ReadPrec GetUnfilteredTableMetadataResponse
$creadPrec :: ReadPrec GetUnfilteredTableMetadataResponse
readList :: ReadS [GetUnfilteredTableMetadataResponse]
$creadList :: ReadS [GetUnfilteredTableMetadataResponse]
readsPrec :: Int -> ReadS GetUnfilteredTableMetadataResponse
$creadsPrec :: Int -> ReadS GetUnfilteredTableMetadataResponse
Prelude.Read, Int -> GetUnfilteredTableMetadataResponse -> ShowS
[GetUnfilteredTableMetadataResponse] -> ShowS
GetUnfilteredTableMetadataResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetUnfilteredTableMetadataResponse] -> ShowS
$cshowList :: [GetUnfilteredTableMetadataResponse] -> ShowS
show :: GetUnfilteredTableMetadataResponse -> String
$cshow :: GetUnfilteredTableMetadataResponse -> String
showsPrec :: Int -> GetUnfilteredTableMetadataResponse -> ShowS
$cshowsPrec :: Int -> GetUnfilteredTableMetadataResponse -> ShowS
Prelude.Show, forall x.
Rep GetUnfilteredTableMetadataResponse x
-> GetUnfilteredTableMetadataResponse
forall x.
GetUnfilteredTableMetadataResponse
-> Rep GetUnfilteredTableMetadataResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetUnfilteredTableMetadataResponse x
-> GetUnfilteredTableMetadataResponse
$cfrom :: forall x.
GetUnfilteredTableMetadataResponse
-> Rep GetUnfilteredTableMetadataResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetUnfilteredTableMetadataResponse' 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:
--
-- 'authorizedColumns', 'getUnfilteredTableMetadataResponse_authorizedColumns' - Undocumented member.
--
-- 'cellFilters', 'getUnfilteredTableMetadataResponse_cellFilters' - Undocumented member.
--
-- 'isRegisteredWithLakeFormation', 'getUnfilteredTableMetadataResponse_isRegisteredWithLakeFormation' - Undocumented member.
--
-- 'table', 'getUnfilteredTableMetadataResponse_table' - Undocumented member.
--
-- 'httpStatus', 'getUnfilteredTableMetadataResponse_httpStatus' - The response's http status code.
newGetUnfilteredTableMetadataResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetUnfilteredTableMetadataResponse
newGetUnfilteredTableMetadataResponse :: Int -> GetUnfilteredTableMetadataResponse
newGetUnfilteredTableMetadataResponse Int
pHttpStatus_ =
  GetUnfilteredTableMetadataResponse'
    { $sel:authorizedColumns:GetUnfilteredTableMetadataResponse' :: Maybe [Text]
authorizedColumns =
        forall a. Maybe a
Prelude.Nothing,
      $sel:cellFilters:GetUnfilteredTableMetadataResponse' :: Maybe [ColumnRowFilter]
cellFilters = forall a. Maybe a
Prelude.Nothing,
      $sel:isRegisteredWithLakeFormation:GetUnfilteredTableMetadataResponse' :: Maybe Bool
isRegisteredWithLakeFormation =
        forall a. Maybe a
Prelude.Nothing,
      $sel:table:GetUnfilteredTableMetadataResponse' :: Maybe Table
table = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetUnfilteredTableMetadataResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
getUnfilteredTableMetadataResponse_authorizedColumns :: Lens.Lens' GetUnfilteredTableMetadataResponse (Prelude.Maybe [Prelude.Text])
getUnfilteredTableMetadataResponse_authorizedColumns :: Lens' GetUnfilteredTableMetadataResponse (Maybe [Text])
getUnfilteredTableMetadataResponse_authorizedColumns = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadataResponse' {Maybe [Text]
authorizedColumns :: Maybe [Text]
$sel:authorizedColumns:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe [Text]
authorizedColumns} -> Maybe [Text]
authorizedColumns) (\s :: GetUnfilteredTableMetadataResponse
s@GetUnfilteredTableMetadataResponse' {} Maybe [Text]
a -> GetUnfilteredTableMetadataResponse
s {$sel:authorizedColumns:GetUnfilteredTableMetadataResponse' :: Maybe [Text]
authorizedColumns = Maybe [Text]
a} :: GetUnfilteredTableMetadataResponse) 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

-- | Undocumented member.
getUnfilteredTableMetadataResponse_cellFilters :: Lens.Lens' GetUnfilteredTableMetadataResponse (Prelude.Maybe [ColumnRowFilter])
getUnfilteredTableMetadataResponse_cellFilters :: Lens' GetUnfilteredTableMetadataResponse (Maybe [ColumnRowFilter])
getUnfilteredTableMetadataResponse_cellFilters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadataResponse' {Maybe [ColumnRowFilter]
cellFilters :: Maybe [ColumnRowFilter]
$sel:cellFilters:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe [ColumnRowFilter]
cellFilters} -> Maybe [ColumnRowFilter]
cellFilters) (\s :: GetUnfilteredTableMetadataResponse
s@GetUnfilteredTableMetadataResponse' {} Maybe [ColumnRowFilter]
a -> GetUnfilteredTableMetadataResponse
s {$sel:cellFilters:GetUnfilteredTableMetadataResponse' :: Maybe [ColumnRowFilter]
cellFilters = Maybe [ColumnRowFilter]
a} :: GetUnfilteredTableMetadataResponse) 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

-- | Undocumented member.
getUnfilteredTableMetadataResponse_isRegisteredWithLakeFormation :: Lens.Lens' GetUnfilteredTableMetadataResponse (Prelude.Maybe Prelude.Bool)
getUnfilteredTableMetadataResponse_isRegisteredWithLakeFormation :: Lens' GetUnfilteredTableMetadataResponse (Maybe Bool)
getUnfilteredTableMetadataResponse_isRegisteredWithLakeFormation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadataResponse' {Maybe Bool
isRegisteredWithLakeFormation :: Maybe Bool
$sel:isRegisteredWithLakeFormation:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe Bool
isRegisteredWithLakeFormation} -> Maybe Bool
isRegisteredWithLakeFormation) (\s :: GetUnfilteredTableMetadataResponse
s@GetUnfilteredTableMetadataResponse' {} Maybe Bool
a -> GetUnfilteredTableMetadataResponse
s {$sel:isRegisteredWithLakeFormation:GetUnfilteredTableMetadataResponse' :: Maybe Bool
isRegisteredWithLakeFormation = Maybe Bool
a} :: GetUnfilteredTableMetadataResponse)

-- | Undocumented member.
getUnfilteredTableMetadataResponse_table :: Lens.Lens' GetUnfilteredTableMetadataResponse (Prelude.Maybe Table)
getUnfilteredTableMetadataResponse_table :: Lens' GetUnfilteredTableMetadataResponse (Maybe Table)
getUnfilteredTableMetadataResponse_table = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredTableMetadataResponse' {Maybe Table
table :: Maybe Table
$sel:table:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe Table
table} -> Maybe Table
table) (\s :: GetUnfilteredTableMetadataResponse
s@GetUnfilteredTableMetadataResponse' {} Maybe Table
a -> GetUnfilteredTableMetadataResponse
s {$sel:table:GetUnfilteredTableMetadataResponse' :: Maybe Table
table = Maybe Table
a} :: GetUnfilteredTableMetadataResponse)

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

instance
  Prelude.NFData
    GetUnfilteredTableMetadataResponse
  where
  rnf :: GetUnfilteredTableMetadataResponse -> ()
rnf GetUnfilteredTableMetadataResponse' {Int
Maybe Bool
Maybe [Text]
Maybe [ColumnRowFilter]
Maybe Table
httpStatus :: Int
table :: Maybe Table
isRegisteredWithLakeFormation :: Maybe Bool
cellFilters :: Maybe [ColumnRowFilter]
authorizedColumns :: Maybe [Text]
$sel:httpStatus:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Int
$sel:table:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe Table
$sel:isRegisteredWithLakeFormation:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe Bool
$sel:cellFilters:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe [ColumnRowFilter]
$sel:authorizedColumns:GetUnfilteredTableMetadataResponse' :: GetUnfilteredTableMetadataResponse -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
authorizedColumns
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ColumnRowFilter]
cellFilters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
isRegisteredWithLakeFormation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Table
table
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus