{-# 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.GetUnfilteredPartitionsMetadata
-- 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.GetUnfilteredPartitionsMetadata
  ( -- * Creating a Request
    GetUnfilteredPartitionsMetadata (..),
    newGetUnfilteredPartitionsMetadata,

    -- * Request Lenses
    getUnfilteredPartitionsMetadata_auditContext,
    getUnfilteredPartitionsMetadata_expression,
    getUnfilteredPartitionsMetadata_maxResults,
    getUnfilteredPartitionsMetadata_nextToken,
    getUnfilteredPartitionsMetadata_segment,
    getUnfilteredPartitionsMetadata_catalogId,
    getUnfilteredPartitionsMetadata_databaseName,
    getUnfilteredPartitionsMetadata_tableName,
    getUnfilteredPartitionsMetadata_supportedPermissionTypes,

    -- * Destructuring the Response
    GetUnfilteredPartitionsMetadataResponse (..),
    newGetUnfilteredPartitionsMetadataResponse,

    -- * Response Lenses
    getUnfilteredPartitionsMetadataResponse_nextToken,
    getUnfilteredPartitionsMetadataResponse_unfilteredPartitions,
    getUnfilteredPartitionsMetadataResponse_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:/ 'newGetUnfilteredPartitionsMetadata' smart constructor.
data GetUnfilteredPartitionsMetadata = GetUnfilteredPartitionsMetadata'
  { GetUnfilteredPartitionsMetadata -> Maybe AuditContext
auditContext :: Prelude.Maybe AuditContext,
    GetUnfilteredPartitionsMetadata -> Maybe Text
expression :: Prelude.Maybe Prelude.Text,
    GetUnfilteredPartitionsMetadata -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    GetUnfilteredPartitionsMetadata -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    GetUnfilteredPartitionsMetadata -> Maybe Segment
segment :: Prelude.Maybe Segment,
    GetUnfilteredPartitionsMetadata -> Text
catalogId :: Prelude.Text,
    GetUnfilteredPartitionsMetadata -> Text
databaseName :: Prelude.Text,
    GetUnfilteredPartitionsMetadata -> Text
tableName :: Prelude.Text,
    GetUnfilteredPartitionsMetadata -> NonEmpty PermissionType
supportedPermissionTypes :: Prelude.NonEmpty PermissionType
  }
  deriving (GetUnfilteredPartitionsMetadata
-> GetUnfilteredPartitionsMetadata -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetUnfilteredPartitionsMetadata
-> GetUnfilteredPartitionsMetadata -> Bool
$c/= :: GetUnfilteredPartitionsMetadata
-> GetUnfilteredPartitionsMetadata -> Bool
== :: GetUnfilteredPartitionsMetadata
-> GetUnfilteredPartitionsMetadata -> Bool
$c== :: GetUnfilteredPartitionsMetadata
-> GetUnfilteredPartitionsMetadata -> Bool
Prelude.Eq, ReadPrec [GetUnfilteredPartitionsMetadata]
ReadPrec GetUnfilteredPartitionsMetadata
Int -> ReadS GetUnfilteredPartitionsMetadata
ReadS [GetUnfilteredPartitionsMetadata]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetUnfilteredPartitionsMetadata]
$creadListPrec :: ReadPrec [GetUnfilteredPartitionsMetadata]
readPrec :: ReadPrec GetUnfilteredPartitionsMetadata
$creadPrec :: ReadPrec GetUnfilteredPartitionsMetadata
readList :: ReadS [GetUnfilteredPartitionsMetadata]
$creadList :: ReadS [GetUnfilteredPartitionsMetadata]
readsPrec :: Int -> ReadS GetUnfilteredPartitionsMetadata
$creadsPrec :: Int -> ReadS GetUnfilteredPartitionsMetadata
Prelude.Read, Int -> GetUnfilteredPartitionsMetadata -> ShowS
[GetUnfilteredPartitionsMetadata] -> ShowS
GetUnfilteredPartitionsMetadata -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetUnfilteredPartitionsMetadata] -> ShowS
$cshowList :: [GetUnfilteredPartitionsMetadata] -> ShowS
show :: GetUnfilteredPartitionsMetadata -> String
$cshow :: GetUnfilteredPartitionsMetadata -> String
showsPrec :: Int -> GetUnfilteredPartitionsMetadata -> ShowS
$cshowsPrec :: Int -> GetUnfilteredPartitionsMetadata -> ShowS
Prelude.Show, forall x.
Rep GetUnfilteredPartitionsMetadata x
-> GetUnfilteredPartitionsMetadata
forall x.
GetUnfilteredPartitionsMetadata
-> Rep GetUnfilteredPartitionsMetadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetUnfilteredPartitionsMetadata x
-> GetUnfilteredPartitionsMetadata
$cfrom :: forall x.
GetUnfilteredPartitionsMetadata
-> Rep GetUnfilteredPartitionsMetadata x
Prelude.Generic)

-- |
-- Create a value of 'GetUnfilteredPartitionsMetadata' 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', 'getUnfilteredPartitionsMetadata_auditContext' - Undocumented member.
--
-- 'expression', 'getUnfilteredPartitionsMetadata_expression' - Undocumented member.
--
-- 'maxResults', 'getUnfilteredPartitionsMetadata_maxResults' - Undocumented member.
--
-- 'nextToken', 'getUnfilteredPartitionsMetadata_nextToken' - Undocumented member.
--
-- 'segment', 'getUnfilteredPartitionsMetadata_segment' - Undocumented member.
--
-- 'catalogId', 'getUnfilteredPartitionsMetadata_catalogId' - Undocumented member.
--
-- 'databaseName', 'getUnfilteredPartitionsMetadata_databaseName' - Undocumented member.
--
-- 'tableName', 'getUnfilteredPartitionsMetadata_tableName' - Undocumented member.
--
-- 'supportedPermissionTypes', 'getUnfilteredPartitionsMetadata_supportedPermissionTypes' - Undocumented member.
newGetUnfilteredPartitionsMetadata ::
  -- | 'catalogId'
  Prelude.Text ->
  -- | 'databaseName'
  Prelude.Text ->
  -- | 'tableName'
  Prelude.Text ->
  -- | 'supportedPermissionTypes'
  Prelude.NonEmpty PermissionType ->
  GetUnfilteredPartitionsMetadata
newGetUnfilteredPartitionsMetadata :: Text
-> Text
-> Text
-> NonEmpty PermissionType
-> GetUnfilteredPartitionsMetadata
newGetUnfilteredPartitionsMetadata
  Text
pCatalogId_
  Text
pDatabaseName_
  Text
pTableName_
  NonEmpty PermissionType
pSupportedPermissionTypes_ =
    GetUnfilteredPartitionsMetadata'
      { $sel:auditContext:GetUnfilteredPartitionsMetadata' :: Maybe AuditContext
auditContext =
          forall a. Maybe a
Prelude.Nothing,
        $sel:expression:GetUnfilteredPartitionsMetadata' :: Maybe Text
expression = forall a. Maybe a
Prelude.Nothing,
        $sel:maxResults:GetUnfilteredPartitionsMetadata' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:GetUnfilteredPartitionsMetadata' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:segment:GetUnfilteredPartitionsMetadata' :: Maybe Segment
segment = forall a. Maybe a
Prelude.Nothing,
        $sel:catalogId:GetUnfilteredPartitionsMetadata' :: Text
catalogId = Text
pCatalogId_,
        $sel:databaseName:GetUnfilteredPartitionsMetadata' :: Text
databaseName = Text
pDatabaseName_,
        $sel:tableName:GetUnfilteredPartitionsMetadata' :: Text
tableName = Text
pTableName_,
        $sel:supportedPermissionTypes:GetUnfilteredPartitionsMetadata' :: 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.
getUnfilteredPartitionsMetadata_auditContext :: Lens.Lens' GetUnfilteredPartitionsMetadata (Prelude.Maybe AuditContext)
getUnfilteredPartitionsMetadata_auditContext :: Lens' GetUnfilteredPartitionsMetadata (Maybe AuditContext)
getUnfilteredPartitionsMetadata_auditContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadata' {Maybe AuditContext
auditContext :: Maybe AuditContext
$sel:auditContext:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe AuditContext
auditContext} -> Maybe AuditContext
auditContext) (\s :: GetUnfilteredPartitionsMetadata
s@GetUnfilteredPartitionsMetadata' {} Maybe AuditContext
a -> GetUnfilteredPartitionsMetadata
s {$sel:auditContext:GetUnfilteredPartitionsMetadata' :: Maybe AuditContext
auditContext = Maybe AuditContext
a} :: GetUnfilteredPartitionsMetadata)

-- | Undocumented member.
getUnfilteredPartitionsMetadata_expression :: Lens.Lens' GetUnfilteredPartitionsMetadata (Prelude.Maybe Prelude.Text)
getUnfilteredPartitionsMetadata_expression :: Lens' GetUnfilteredPartitionsMetadata (Maybe Text)
getUnfilteredPartitionsMetadata_expression = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadata' {Maybe Text
expression :: Maybe Text
$sel:expression:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
expression} -> Maybe Text
expression) (\s :: GetUnfilteredPartitionsMetadata
s@GetUnfilteredPartitionsMetadata' {} Maybe Text
a -> GetUnfilteredPartitionsMetadata
s {$sel:expression:GetUnfilteredPartitionsMetadata' :: Maybe Text
expression = Maybe Text
a} :: GetUnfilteredPartitionsMetadata)

-- | Undocumented member.
getUnfilteredPartitionsMetadata_maxResults :: Lens.Lens' GetUnfilteredPartitionsMetadata (Prelude.Maybe Prelude.Natural)
getUnfilteredPartitionsMetadata_maxResults :: Lens' GetUnfilteredPartitionsMetadata (Maybe Natural)
getUnfilteredPartitionsMetadata_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadata' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: GetUnfilteredPartitionsMetadata
s@GetUnfilteredPartitionsMetadata' {} Maybe Natural
a -> GetUnfilteredPartitionsMetadata
s {$sel:maxResults:GetUnfilteredPartitionsMetadata' :: Maybe Natural
maxResults = Maybe Natural
a} :: GetUnfilteredPartitionsMetadata)

-- | Undocumented member.
getUnfilteredPartitionsMetadata_nextToken :: Lens.Lens' GetUnfilteredPartitionsMetadata (Prelude.Maybe Prelude.Text)
getUnfilteredPartitionsMetadata_nextToken :: Lens' GetUnfilteredPartitionsMetadata (Maybe Text)
getUnfilteredPartitionsMetadata_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadata' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetUnfilteredPartitionsMetadata
s@GetUnfilteredPartitionsMetadata' {} Maybe Text
a -> GetUnfilteredPartitionsMetadata
s {$sel:nextToken:GetUnfilteredPartitionsMetadata' :: Maybe Text
nextToken = Maybe Text
a} :: GetUnfilteredPartitionsMetadata)

-- | Undocumented member.
getUnfilteredPartitionsMetadata_segment :: Lens.Lens' GetUnfilteredPartitionsMetadata (Prelude.Maybe Segment)
getUnfilteredPartitionsMetadata_segment :: Lens' GetUnfilteredPartitionsMetadata (Maybe Segment)
getUnfilteredPartitionsMetadata_segment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadata' {Maybe Segment
segment :: Maybe Segment
$sel:segment:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Segment
segment} -> Maybe Segment
segment) (\s :: GetUnfilteredPartitionsMetadata
s@GetUnfilteredPartitionsMetadata' {} Maybe Segment
a -> GetUnfilteredPartitionsMetadata
s {$sel:segment:GetUnfilteredPartitionsMetadata' :: Maybe Segment
segment = Maybe Segment
a} :: GetUnfilteredPartitionsMetadata)

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

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

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

-- | Undocumented member.
getUnfilteredPartitionsMetadata_supportedPermissionTypes :: Lens.Lens' GetUnfilteredPartitionsMetadata (Prelude.NonEmpty PermissionType)
getUnfilteredPartitionsMetadata_supportedPermissionTypes :: Lens' GetUnfilteredPartitionsMetadata (NonEmpty PermissionType)
getUnfilteredPartitionsMetadata_supportedPermissionTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadata' {NonEmpty PermissionType
supportedPermissionTypes :: NonEmpty PermissionType
$sel:supportedPermissionTypes:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> NonEmpty PermissionType
supportedPermissionTypes} -> NonEmpty PermissionType
supportedPermissionTypes) (\s :: GetUnfilteredPartitionsMetadata
s@GetUnfilteredPartitionsMetadata' {} NonEmpty PermissionType
a -> GetUnfilteredPartitionsMetadata
s {$sel:supportedPermissionTypes:GetUnfilteredPartitionsMetadata' :: NonEmpty PermissionType
supportedPermissionTypes = NonEmpty PermissionType
a} :: GetUnfilteredPartitionsMetadata) 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
    GetUnfilteredPartitionsMetadata
  where
  type
    AWSResponse GetUnfilteredPartitionsMetadata =
      GetUnfilteredPartitionsMetadataResponse
  request :: (Service -> Service)
-> GetUnfilteredPartitionsMetadata
-> Request GetUnfilteredPartitionsMetadata
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 GetUnfilteredPartitionsMetadata
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse GetUnfilteredPartitionsMetadata)))
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 [UnfilteredPartition]
-> Int
-> GetUnfilteredPartitionsMetadataResponse
GetUnfilteredPartitionsMetadataResponse'
            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.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"UnfilteredPartitions"
                            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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance
  Prelude.Hashable
    GetUnfilteredPartitionsMetadata
  where
  hashWithSalt :: Int -> GetUnfilteredPartitionsMetadata -> Int
hashWithSalt
    Int
_salt
    GetUnfilteredPartitionsMetadata' {Maybe Natural
Maybe Text
Maybe AuditContext
Maybe Segment
NonEmpty PermissionType
Text
supportedPermissionTypes :: NonEmpty PermissionType
tableName :: Text
databaseName :: Text
catalogId :: Text
segment :: Maybe Segment
nextToken :: Maybe Text
maxResults :: Maybe Natural
expression :: Maybe Text
auditContext :: Maybe AuditContext
$sel:supportedPermissionTypes:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> NonEmpty PermissionType
$sel:tableName:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:databaseName:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:catalogId:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:segment:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Segment
$sel:nextToken:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
$sel:maxResults:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Natural
$sel:expression:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
$sel:auditContext:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> 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` Maybe Text
expression
        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` Maybe Segment
segment
        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
tableName
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty PermissionType
supportedPermissionTypes

instance
  Prelude.NFData
    GetUnfilteredPartitionsMetadata
  where
  rnf :: GetUnfilteredPartitionsMetadata -> ()
rnf GetUnfilteredPartitionsMetadata' {Maybe Natural
Maybe Text
Maybe AuditContext
Maybe Segment
NonEmpty PermissionType
Text
supportedPermissionTypes :: NonEmpty PermissionType
tableName :: Text
databaseName :: Text
catalogId :: Text
segment :: Maybe Segment
nextToken :: Maybe Text
maxResults :: Maybe Natural
expression :: Maybe Text
auditContext :: Maybe AuditContext
$sel:supportedPermissionTypes:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> NonEmpty PermissionType
$sel:tableName:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:databaseName:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:catalogId:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:segment:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Segment
$sel:nextToken:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
$sel:maxResults:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Natural
$sel:expression:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
$sel:auditContext:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> 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 Maybe Text
expression
      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 Maybe Segment
segment
      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
tableName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty PermissionType
supportedPermissionTypes

instance
  Data.ToHeaders
    GetUnfilteredPartitionsMetadata
  where
  toHeaders :: GetUnfilteredPartitionsMetadata -> 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.GetUnfilteredPartitionsMetadata" ::
                          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 GetUnfilteredPartitionsMetadata where
  toJSON :: GetUnfilteredPartitionsMetadata -> Value
toJSON GetUnfilteredPartitionsMetadata' {Maybe Natural
Maybe Text
Maybe AuditContext
Maybe Segment
NonEmpty PermissionType
Text
supportedPermissionTypes :: NonEmpty PermissionType
tableName :: Text
databaseName :: Text
catalogId :: Text
segment :: Maybe Segment
nextToken :: Maybe Text
maxResults :: Maybe Natural
expression :: Maybe Text
auditContext :: Maybe AuditContext
$sel:supportedPermissionTypes:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> NonEmpty PermissionType
$sel:tableName:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:databaseName:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:catalogId:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Text
$sel:segment:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Segment
$sel:nextToken:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
$sel:maxResults:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Natural
$sel:expression:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> Maybe Text
$sel:auditContext:GetUnfilteredPartitionsMetadata' :: GetUnfilteredPartitionsMetadata -> 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,
            (Key
"Expression" 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
expression,
            (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,
            (Key
"Segment" 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 Segment
segment,
            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
"TableName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
tableName),
            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 GetUnfilteredPartitionsMetadata where
  toPath :: GetUnfilteredPartitionsMetadata -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

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

-- |
-- Create a value of 'GetUnfilteredPartitionsMetadataResponse' 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', 'getUnfilteredPartitionsMetadataResponse_nextToken' - Undocumented member.
--
-- 'unfilteredPartitions', 'getUnfilteredPartitionsMetadataResponse_unfilteredPartitions' - Undocumented member.
--
-- 'httpStatus', 'getUnfilteredPartitionsMetadataResponse_httpStatus' - The response's http status code.
newGetUnfilteredPartitionsMetadataResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetUnfilteredPartitionsMetadataResponse
newGetUnfilteredPartitionsMetadataResponse :: Int -> GetUnfilteredPartitionsMetadataResponse
newGetUnfilteredPartitionsMetadataResponse
  Int
pHttpStatus_ =
    GetUnfilteredPartitionsMetadataResponse'
      { $sel:nextToken:GetUnfilteredPartitionsMetadataResponse' :: Maybe Text
nextToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:unfilteredPartitions:GetUnfilteredPartitionsMetadataResponse' :: Maybe [UnfilteredPartition]
unfilteredPartitions =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:GetUnfilteredPartitionsMetadataResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Undocumented member.
getUnfilteredPartitionsMetadataResponse_nextToken :: Lens.Lens' GetUnfilteredPartitionsMetadataResponse (Prelude.Maybe Prelude.Text)
getUnfilteredPartitionsMetadataResponse_nextToken :: Lens' GetUnfilteredPartitionsMetadataResponse (Maybe Text)
getUnfilteredPartitionsMetadataResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadataResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetUnfilteredPartitionsMetadataResponse' :: GetUnfilteredPartitionsMetadataResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetUnfilteredPartitionsMetadataResponse
s@GetUnfilteredPartitionsMetadataResponse' {} Maybe Text
a -> GetUnfilteredPartitionsMetadataResponse
s {$sel:nextToken:GetUnfilteredPartitionsMetadataResponse' :: Maybe Text
nextToken = Maybe Text
a} :: GetUnfilteredPartitionsMetadataResponse)

-- | Undocumented member.
getUnfilteredPartitionsMetadataResponse_unfilteredPartitions :: Lens.Lens' GetUnfilteredPartitionsMetadataResponse (Prelude.Maybe [UnfilteredPartition])
getUnfilteredPartitionsMetadataResponse_unfilteredPartitions :: Lens'
  GetUnfilteredPartitionsMetadataResponse
  (Maybe [UnfilteredPartition])
getUnfilteredPartitionsMetadataResponse_unfilteredPartitions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadataResponse' {Maybe [UnfilteredPartition]
unfilteredPartitions :: Maybe [UnfilteredPartition]
$sel:unfilteredPartitions:GetUnfilteredPartitionsMetadataResponse' :: GetUnfilteredPartitionsMetadataResponse
-> Maybe [UnfilteredPartition]
unfilteredPartitions} -> Maybe [UnfilteredPartition]
unfilteredPartitions) (\s :: GetUnfilteredPartitionsMetadataResponse
s@GetUnfilteredPartitionsMetadataResponse' {} Maybe [UnfilteredPartition]
a -> GetUnfilteredPartitionsMetadataResponse
s {$sel:unfilteredPartitions:GetUnfilteredPartitionsMetadataResponse' :: Maybe [UnfilteredPartition]
unfilteredPartitions = Maybe [UnfilteredPartition]
a} :: GetUnfilteredPartitionsMetadataResponse) 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 response's http status code.
getUnfilteredPartitionsMetadataResponse_httpStatus :: Lens.Lens' GetUnfilteredPartitionsMetadataResponse Prelude.Int
getUnfilteredPartitionsMetadataResponse_httpStatus :: Lens' GetUnfilteredPartitionsMetadataResponse Int
getUnfilteredPartitionsMetadataResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUnfilteredPartitionsMetadataResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetUnfilteredPartitionsMetadataResponse' :: GetUnfilteredPartitionsMetadataResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetUnfilteredPartitionsMetadataResponse
s@GetUnfilteredPartitionsMetadataResponse' {} Int
a -> GetUnfilteredPartitionsMetadataResponse
s {$sel:httpStatus:GetUnfilteredPartitionsMetadataResponse' :: Int
httpStatus = Int
a} :: GetUnfilteredPartitionsMetadataResponse)

instance
  Prelude.NFData
    GetUnfilteredPartitionsMetadataResponse
  where
  rnf :: GetUnfilteredPartitionsMetadataResponse -> ()
rnf GetUnfilteredPartitionsMetadataResponse' {Int
Maybe [UnfilteredPartition]
Maybe Text
httpStatus :: Int
unfilteredPartitions :: Maybe [UnfilteredPartition]
nextToken :: Maybe Text
$sel:httpStatus:GetUnfilteredPartitionsMetadataResponse' :: GetUnfilteredPartitionsMetadataResponse -> Int
$sel:unfilteredPartitions:GetUnfilteredPartitionsMetadataResponse' :: GetUnfilteredPartitionsMetadataResponse
-> Maybe [UnfilteredPartition]
$sel:nextToken:GetUnfilteredPartitionsMetadataResponse' :: GetUnfilteredPartitionsMetadataResponse -> 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 Maybe [UnfilteredPartition]
unfilteredPartitions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus