{-# 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.QuerySchemaVersionMetadata
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Queries for the schema version metadata information.
module Amazonka.Glue.QuerySchemaVersionMetadata
  ( -- * Creating a Request
    QuerySchemaVersionMetadata (..),
    newQuerySchemaVersionMetadata,

    -- * Request Lenses
    querySchemaVersionMetadata_maxResults,
    querySchemaVersionMetadata_metadataList,
    querySchemaVersionMetadata_nextToken,
    querySchemaVersionMetadata_schemaId,
    querySchemaVersionMetadata_schemaVersionId,
    querySchemaVersionMetadata_schemaVersionNumber,

    -- * Destructuring the Response
    QuerySchemaVersionMetadataResponse (..),
    newQuerySchemaVersionMetadataResponse,

    -- * Response Lenses
    querySchemaVersionMetadataResponse_metadataInfoMap,
    querySchemaVersionMetadataResponse_nextToken,
    querySchemaVersionMetadataResponse_schemaVersionId,
    querySchemaVersionMetadataResponse_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:/ 'newQuerySchemaVersionMetadata' smart constructor.
data QuerySchemaVersionMetadata = QuerySchemaVersionMetadata'
  { -- | Maximum number of results required per page. If the value is not
    -- supplied, this will be defaulted to 25 per page.
    QuerySchemaVersionMetadata -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | Search key-value pairs for metadata, if they are not provided all the
    -- metadata information will be fetched.
    QuerySchemaVersionMetadata -> Maybe [MetadataKeyValuePair]
metadataList :: Prelude.Maybe [MetadataKeyValuePair],
    -- | A continuation token, if this is a continuation call.
    QuerySchemaVersionMetadata -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A wrapper structure that may contain the schema name and Amazon Resource
    -- Name (ARN).
    QuerySchemaVersionMetadata -> Maybe SchemaId
schemaId :: Prelude.Maybe SchemaId,
    -- | The unique version ID of the schema version.
    QuerySchemaVersionMetadata -> Maybe Text
schemaVersionId :: Prelude.Maybe Prelude.Text,
    -- | The version number of the schema.
    QuerySchemaVersionMetadata -> Maybe SchemaVersionNumber
schemaVersionNumber :: Prelude.Maybe SchemaVersionNumber
  }
  deriving (QuerySchemaVersionMetadata -> QuerySchemaVersionMetadata -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QuerySchemaVersionMetadata -> QuerySchemaVersionMetadata -> Bool
$c/= :: QuerySchemaVersionMetadata -> QuerySchemaVersionMetadata -> Bool
== :: QuerySchemaVersionMetadata -> QuerySchemaVersionMetadata -> Bool
$c== :: QuerySchemaVersionMetadata -> QuerySchemaVersionMetadata -> Bool
Prelude.Eq, ReadPrec [QuerySchemaVersionMetadata]
ReadPrec QuerySchemaVersionMetadata
Int -> ReadS QuerySchemaVersionMetadata
ReadS [QuerySchemaVersionMetadata]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [QuerySchemaVersionMetadata]
$creadListPrec :: ReadPrec [QuerySchemaVersionMetadata]
readPrec :: ReadPrec QuerySchemaVersionMetadata
$creadPrec :: ReadPrec QuerySchemaVersionMetadata
readList :: ReadS [QuerySchemaVersionMetadata]
$creadList :: ReadS [QuerySchemaVersionMetadata]
readsPrec :: Int -> ReadS QuerySchemaVersionMetadata
$creadsPrec :: Int -> ReadS QuerySchemaVersionMetadata
Prelude.Read, Int -> QuerySchemaVersionMetadata -> ShowS
[QuerySchemaVersionMetadata] -> ShowS
QuerySchemaVersionMetadata -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QuerySchemaVersionMetadata] -> ShowS
$cshowList :: [QuerySchemaVersionMetadata] -> ShowS
show :: QuerySchemaVersionMetadata -> String
$cshow :: QuerySchemaVersionMetadata -> String
showsPrec :: Int -> QuerySchemaVersionMetadata -> ShowS
$cshowsPrec :: Int -> QuerySchemaVersionMetadata -> ShowS
Prelude.Show, forall x.
Rep QuerySchemaVersionMetadata x -> QuerySchemaVersionMetadata
forall x.
QuerySchemaVersionMetadata -> Rep QuerySchemaVersionMetadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep QuerySchemaVersionMetadata x -> QuerySchemaVersionMetadata
$cfrom :: forall x.
QuerySchemaVersionMetadata -> Rep QuerySchemaVersionMetadata x
Prelude.Generic)

-- |
-- Create a value of 'QuerySchemaVersionMetadata' 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:
--
-- 'maxResults', 'querySchemaVersionMetadata_maxResults' - Maximum number of results required per page. If the value is not
-- supplied, this will be defaulted to 25 per page.
--
-- 'metadataList', 'querySchemaVersionMetadata_metadataList' - Search key-value pairs for metadata, if they are not provided all the
-- metadata information will be fetched.
--
-- 'nextToken', 'querySchemaVersionMetadata_nextToken' - A continuation token, if this is a continuation call.
--
-- 'schemaId', 'querySchemaVersionMetadata_schemaId' - A wrapper structure that may contain the schema name and Amazon Resource
-- Name (ARN).
--
-- 'schemaVersionId', 'querySchemaVersionMetadata_schemaVersionId' - The unique version ID of the schema version.
--
-- 'schemaVersionNumber', 'querySchemaVersionMetadata_schemaVersionNumber' - The version number of the schema.
newQuerySchemaVersionMetadata ::
  QuerySchemaVersionMetadata
newQuerySchemaVersionMetadata :: QuerySchemaVersionMetadata
newQuerySchemaVersionMetadata =
  QuerySchemaVersionMetadata'
    { $sel:maxResults:QuerySchemaVersionMetadata' :: Maybe Natural
maxResults =
        forall a. Maybe a
Prelude.Nothing,
      $sel:metadataList:QuerySchemaVersionMetadata' :: Maybe [MetadataKeyValuePair]
metadataList = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:QuerySchemaVersionMetadata' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaId:QuerySchemaVersionMetadata' :: Maybe SchemaId
schemaId = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaVersionId:QuerySchemaVersionMetadata' :: Maybe Text
schemaVersionId = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaVersionNumber:QuerySchemaVersionMetadata' :: Maybe SchemaVersionNumber
schemaVersionNumber = forall a. Maybe a
Prelude.Nothing
    }

-- | Maximum number of results required per page. If the value is not
-- supplied, this will be defaulted to 25 per page.
querySchemaVersionMetadata_maxResults :: Lens.Lens' QuerySchemaVersionMetadata (Prelude.Maybe Prelude.Natural)
querySchemaVersionMetadata_maxResults :: Lens' QuerySchemaVersionMetadata (Maybe Natural)
querySchemaVersionMetadata_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadata' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: QuerySchemaVersionMetadata
s@QuerySchemaVersionMetadata' {} Maybe Natural
a -> QuerySchemaVersionMetadata
s {$sel:maxResults:QuerySchemaVersionMetadata' :: Maybe Natural
maxResults = Maybe Natural
a} :: QuerySchemaVersionMetadata)

-- | Search key-value pairs for metadata, if they are not provided all the
-- metadata information will be fetched.
querySchemaVersionMetadata_metadataList :: Lens.Lens' QuerySchemaVersionMetadata (Prelude.Maybe [MetadataKeyValuePair])
querySchemaVersionMetadata_metadataList :: Lens' QuerySchemaVersionMetadata (Maybe [MetadataKeyValuePair])
querySchemaVersionMetadata_metadataList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadata' {Maybe [MetadataKeyValuePair]
metadataList :: Maybe [MetadataKeyValuePair]
$sel:metadataList:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe [MetadataKeyValuePair]
metadataList} -> Maybe [MetadataKeyValuePair]
metadataList) (\s :: QuerySchemaVersionMetadata
s@QuerySchemaVersionMetadata' {} Maybe [MetadataKeyValuePair]
a -> QuerySchemaVersionMetadata
s {$sel:metadataList:QuerySchemaVersionMetadata' :: Maybe [MetadataKeyValuePair]
metadataList = Maybe [MetadataKeyValuePair]
a} :: QuerySchemaVersionMetadata) 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, if this is a continuation call.
querySchemaVersionMetadata_nextToken :: Lens.Lens' QuerySchemaVersionMetadata (Prelude.Maybe Prelude.Text)
querySchemaVersionMetadata_nextToken :: Lens' QuerySchemaVersionMetadata (Maybe Text)
querySchemaVersionMetadata_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadata' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: QuerySchemaVersionMetadata
s@QuerySchemaVersionMetadata' {} Maybe Text
a -> QuerySchemaVersionMetadata
s {$sel:nextToken:QuerySchemaVersionMetadata' :: Maybe Text
nextToken = Maybe Text
a} :: QuerySchemaVersionMetadata)

-- | A wrapper structure that may contain the schema name and Amazon Resource
-- Name (ARN).
querySchemaVersionMetadata_schemaId :: Lens.Lens' QuerySchemaVersionMetadata (Prelude.Maybe SchemaId)
querySchemaVersionMetadata_schemaId :: Lens' QuerySchemaVersionMetadata (Maybe SchemaId)
querySchemaVersionMetadata_schemaId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadata' {Maybe SchemaId
schemaId :: Maybe SchemaId
$sel:schemaId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaId
schemaId} -> Maybe SchemaId
schemaId) (\s :: QuerySchemaVersionMetadata
s@QuerySchemaVersionMetadata' {} Maybe SchemaId
a -> QuerySchemaVersionMetadata
s {$sel:schemaId:QuerySchemaVersionMetadata' :: Maybe SchemaId
schemaId = Maybe SchemaId
a} :: QuerySchemaVersionMetadata)

-- | The unique version ID of the schema version.
querySchemaVersionMetadata_schemaVersionId :: Lens.Lens' QuerySchemaVersionMetadata (Prelude.Maybe Prelude.Text)
querySchemaVersionMetadata_schemaVersionId :: Lens' QuerySchemaVersionMetadata (Maybe Text)
querySchemaVersionMetadata_schemaVersionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadata' {Maybe Text
schemaVersionId :: Maybe Text
$sel:schemaVersionId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
schemaVersionId} -> Maybe Text
schemaVersionId) (\s :: QuerySchemaVersionMetadata
s@QuerySchemaVersionMetadata' {} Maybe Text
a -> QuerySchemaVersionMetadata
s {$sel:schemaVersionId:QuerySchemaVersionMetadata' :: Maybe Text
schemaVersionId = Maybe Text
a} :: QuerySchemaVersionMetadata)

-- | The version number of the schema.
querySchemaVersionMetadata_schemaVersionNumber :: Lens.Lens' QuerySchemaVersionMetadata (Prelude.Maybe SchemaVersionNumber)
querySchemaVersionMetadata_schemaVersionNumber :: Lens' QuerySchemaVersionMetadata (Maybe SchemaVersionNumber)
querySchemaVersionMetadata_schemaVersionNumber = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadata' {Maybe SchemaVersionNumber
schemaVersionNumber :: Maybe SchemaVersionNumber
$sel:schemaVersionNumber:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaVersionNumber
schemaVersionNumber} -> Maybe SchemaVersionNumber
schemaVersionNumber) (\s :: QuerySchemaVersionMetadata
s@QuerySchemaVersionMetadata' {} Maybe SchemaVersionNumber
a -> QuerySchemaVersionMetadata
s {$sel:schemaVersionNumber:QuerySchemaVersionMetadata' :: Maybe SchemaVersionNumber
schemaVersionNumber = Maybe SchemaVersionNumber
a} :: QuerySchemaVersionMetadata)

instance Core.AWSRequest QuerySchemaVersionMetadata where
  type
    AWSResponse QuerySchemaVersionMetadata =
      QuerySchemaVersionMetadataResponse
  request :: (Service -> Service)
-> QuerySchemaVersionMetadata -> Request QuerySchemaVersionMetadata
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 QuerySchemaVersionMetadata
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse QuerySchemaVersionMetadata)))
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 (HashMap Text MetadataInfo)
-> Maybe Text
-> Maybe Text
-> Int
-> QuerySchemaVersionMetadataResponse
QuerySchemaVersionMetadataResponse'
            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
"MetadataInfoMap"
                            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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"SchemaVersionId")
            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 QuerySchemaVersionMetadata where
  hashWithSalt :: Int -> QuerySchemaVersionMetadata -> Int
hashWithSalt Int
_salt QuerySchemaVersionMetadata' {Maybe Natural
Maybe [MetadataKeyValuePair]
Maybe Text
Maybe SchemaId
Maybe SchemaVersionNumber
schemaVersionNumber :: Maybe SchemaVersionNumber
schemaVersionId :: Maybe Text
schemaId :: Maybe SchemaId
nextToken :: Maybe Text
metadataList :: Maybe [MetadataKeyValuePair]
maxResults :: Maybe Natural
$sel:schemaVersionNumber:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaVersionNumber
$sel:schemaVersionId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
$sel:schemaId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaId
$sel:nextToken:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
$sel:metadataList:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe [MetadataKeyValuePair]
$sel:maxResults:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [MetadataKeyValuePair]
metadataList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SchemaId
schemaId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
schemaVersionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SchemaVersionNumber
schemaVersionNumber

instance Prelude.NFData QuerySchemaVersionMetadata where
  rnf :: QuerySchemaVersionMetadata -> ()
rnf QuerySchemaVersionMetadata' {Maybe Natural
Maybe [MetadataKeyValuePair]
Maybe Text
Maybe SchemaId
Maybe SchemaVersionNumber
schemaVersionNumber :: Maybe SchemaVersionNumber
schemaVersionId :: Maybe Text
schemaId :: Maybe SchemaId
nextToken :: Maybe Text
metadataList :: Maybe [MetadataKeyValuePair]
maxResults :: Maybe Natural
$sel:schemaVersionNumber:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaVersionNumber
$sel:schemaVersionId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
$sel:schemaId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaId
$sel:nextToken:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
$sel:metadataList:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe [MetadataKeyValuePair]
$sel:maxResults:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Natural
..} =
    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 [MetadataKeyValuePair]
metadataList
      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 SchemaId
schemaId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
schemaVersionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SchemaVersionNumber
schemaVersionNumber

instance Data.ToHeaders QuerySchemaVersionMetadata where
  toHeaders :: QuerySchemaVersionMetadata -> 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.QuerySchemaVersionMetadata" ::
                          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 QuerySchemaVersionMetadata where
  toJSON :: QuerySchemaVersionMetadata -> Value
toJSON QuerySchemaVersionMetadata' {Maybe Natural
Maybe [MetadataKeyValuePair]
Maybe Text
Maybe SchemaId
Maybe SchemaVersionNumber
schemaVersionNumber :: Maybe SchemaVersionNumber
schemaVersionId :: Maybe Text
schemaId :: Maybe SchemaId
nextToken :: Maybe Text
metadataList :: Maybe [MetadataKeyValuePair]
maxResults :: Maybe Natural
$sel:schemaVersionNumber:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaVersionNumber
$sel:schemaVersionId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
$sel:schemaId:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe SchemaId
$sel:nextToken:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Text
$sel:metadataList:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe [MetadataKeyValuePair]
$sel:maxResults:QuerySchemaVersionMetadata' :: QuerySchemaVersionMetadata -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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
"MetadataList" 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 [MetadataKeyValuePair]
metadataList,
            (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
"SchemaId" 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 SchemaId
schemaId,
            (Key
"SchemaVersionId" 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
schemaVersionId,
            (Key
"SchemaVersionNumber" 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 SchemaVersionNumber
schemaVersionNumber
          ]
      )

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

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

-- | /See:/ 'newQuerySchemaVersionMetadataResponse' smart constructor.
data QuerySchemaVersionMetadataResponse = QuerySchemaVersionMetadataResponse'
  { -- | A map of a metadata key and associated values.
    QuerySchemaVersionMetadataResponse
-> Maybe (HashMap Text MetadataInfo)
metadataInfoMap :: Prelude.Maybe (Prelude.HashMap Prelude.Text MetadataInfo),
    -- | A continuation token for paginating the returned list of tokens,
    -- returned if the current segment of the list is not the last.
    QuerySchemaVersionMetadataResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The unique version ID of the schema version.
    QuerySchemaVersionMetadataResponse -> Maybe Text
schemaVersionId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    QuerySchemaVersionMetadataResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (QuerySchemaVersionMetadataResponse
-> QuerySchemaVersionMetadataResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QuerySchemaVersionMetadataResponse
-> QuerySchemaVersionMetadataResponse -> Bool
$c/= :: QuerySchemaVersionMetadataResponse
-> QuerySchemaVersionMetadataResponse -> Bool
== :: QuerySchemaVersionMetadataResponse
-> QuerySchemaVersionMetadataResponse -> Bool
$c== :: QuerySchemaVersionMetadataResponse
-> QuerySchemaVersionMetadataResponse -> Bool
Prelude.Eq, ReadPrec [QuerySchemaVersionMetadataResponse]
ReadPrec QuerySchemaVersionMetadataResponse
Int -> ReadS QuerySchemaVersionMetadataResponse
ReadS [QuerySchemaVersionMetadataResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [QuerySchemaVersionMetadataResponse]
$creadListPrec :: ReadPrec [QuerySchemaVersionMetadataResponse]
readPrec :: ReadPrec QuerySchemaVersionMetadataResponse
$creadPrec :: ReadPrec QuerySchemaVersionMetadataResponse
readList :: ReadS [QuerySchemaVersionMetadataResponse]
$creadList :: ReadS [QuerySchemaVersionMetadataResponse]
readsPrec :: Int -> ReadS QuerySchemaVersionMetadataResponse
$creadsPrec :: Int -> ReadS QuerySchemaVersionMetadataResponse
Prelude.Read, Int -> QuerySchemaVersionMetadataResponse -> ShowS
[QuerySchemaVersionMetadataResponse] -> ShowS
QuerySchemaVersionMetadataResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QuerySchemaVersionMetadataResponse] -> ShowS
$cshowList :: [QuerySchemaVersionMetadataResponse] -> ShowS
show :: QuerySchemaVersionMetadataResponse -> String
$cshow :: QuerySchemaVersionMetadataResponse -> String
showsPrec :: Int -> QuerySchemaVersionMetadataResponse -> ShowS
$cshowsPrec :: Int -> QuerySchemaVersionMetadataResponse -> ShowS
Prelude.Show, forall x.
Rep QuerySchemaVersionMetadataResponse x
-> QuerySchemaVersionMetadataResponse
forall x.
QuerySchemaVersionMetadataResponse
-> Rep QuerySchemaVersionMetadataResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep QuerySchemaVersionMetadataResponse x
-> QuerySchemaVersionMetadataResponse
$cfrom :: forall x.
QuerySchemaVersionMetadataResponse
-> Rep QuerySchemaVersionMetadataResponse x
Prelude.Generic)

-- |
-- Create a value of 'QuerySchemaVersionMetadataResponse' 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:
--
-- 'metadataInfoMap', 'querySchemaVersionMetadataResponse_metadataInfoMap' - A map of a metadata key and associated values.
--
-- 'nextToken', 'querySchemaVersionMetadataResponse_nextToken' - A continuation token for paginating the returned list of tokens,
-- returned if the current segment of the list is not the last.
--
-- 'schemaVersionId', 'querySchemaVersionMetadataResponse_schemaVersionId' - The unique version ID of the schema version.
--
-- 'httpStatus', 'querySchemaVersionMetadataResponse_httpStatus' - The response's http status code.
newQuerySchemaVersionMetadataResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  QuerySchemaVersionMetadataResponse
newQuerySchemaVersionMetadataResponse :: Int -> QuerySchemaVersionMetadataResponse
newQuerySchemaVersionMetadataResponse Int
pHttpStatus_ =
  QuerySchemaVersionMetadataResponse'
    { $sel:metadataInfoMap:QuerySchemaVersionMetadataResponse' :: Maybe (HashMap Text MetadataInfo)
metadataInfoMap =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:QuerySchemaVersionMetadataResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaVersionId:QuerySchemaVersionMetadataResponse' :: Maybe Text
schemaVersionId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:QuerySchemaVersionMetadataResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A map of a metadata key and associated values.
querySchemaVersionMetadataResponse_metadataInfoMap :: Lens.Lens' QuerySchemaVersionMetadataResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text MetadataInfo))
querySchemaVersionMetadataResponse_metadataInfoMap :: Lens'
  QuerySchemaVersionMetadataResponse
  (Maybe (HashMap Text MetadataInfo))
querySchemaVersionMetadataResponse_metadataInfoMap = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadataResponse' {Maybe (HashMap Text MetadataInfo)
metadataInfoMap :: Maybe (HashMap Text MetadataInfo)
$sel:metadataInfoMap:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse
-> Maybe (HashMap Text MetadataInfo)
metadataInfoMap} -> Maybe (HashMap Text MetadataInfo)
metadataInfoMap) (\s :: QuerySchemaVersionMetadataResponse
s@QuerySchemaVersionMetadataResponse' {} Maybe (HashMap Text MetadataInfo)
a -> QuerySchemaVersionMetadataResponse
s {$sel:metadataInfoMap:QuerySchemaVersionMetadataResponse' :: Maybe (HashMap Text MetadataInfo)
metadataInfoMap = Maybe (HashMap Text MetadataInfo)
a} :: QuerySchemaVersionMetadataResponse) 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 for paginating the returned list of tokens,
-- returned if the current segment of the list is not the last.
querySchemaVersionMetadataResponse_nextToken :: Lens.Lens' QuerySchemaVersionMetadataResponse (Prelude.Maybe Prelude.Text)
querySchemaVersionMetadataResponse_nextToken :: Lens' QuerySchemaVersionMetadataResponse (Maybe Text)
querySchemaVersionMetadataResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadataResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: QuerySchemaVersionMetadataResponse
s@QuerySchemaVersionMetadataResponse' {} Maybe Text
a -> QuerySchemaVersionMetadataResponse
s {$sel:nextToken:QuerySchemaVersionMetadataResponse' :: Maybe Text
nextToken = Maybe Text
a} :: QuerySchemaVersionMetadataResponse)

-- | The unique version ID of the schema version.
querySchemaVersionMetadataResponse_schemaVersionId :: Lens.Lens' QuerySchemaVersionMetadataResponse (Prelude.Maybe Prelude.Text)
querySchemaVersionMetadataResponse_schemaVersionId :: Lens' QuerySchemaVersionMetadataResponse (Maybe Text)
querySchemaVersionMetadataResponse_schemaVersionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QuerySchemaVersionMetadataResponse' {Maybe Text
schemaVersionId :: Maybe Text
$sel:schemaVersionId:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse -> Maybe Text
schemaVersionId} -> Maybe Text
schemaVersionId) (\s :: QuerySchemaVersionMetadataResponse
s@QuerySchemaVersionMetadataResponse' {} Maybe Text
a -> QuerySchemaVersionMetadataResponse
s {$sel:schemaVersionId:QuerySchemaVersionMetadataResponse' :: Maybe Text
schemaVersionId = Maybe Text
a} :: QuerySchemaVersionMetadataResponse)

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

instance
  Prelude.NFData
    QuerySchemaVersionMetadataResponse
  where
  rnf :: QuerySchemaVersionMetadataResponse -> ()
rnf QuerySchemaVersionMetadataResponse' {Int
Maybe Text
Maybe (HashMap Text MetadataInfo)
httpStatus :: Int
schemaVersionId :: Maybe Text
nextToken :: Maybe Text
metadataInfoMap :: Maybe (HashMap Text MetadataInfo)
$sel:httpStatus:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse -> Int
$sel:schemaVersionId:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse -> Maybe Text
$sel:nextToken:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse -> Maybe Text
$sel:metadataInfoMap:QuerySchemaVersionMetadataResponse' :: QuerySchemaVersionMetadataResponse
-> Maybe (HashMap Text MetadataInfo)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text MetadataInfo)
metadataInfoMap
      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 Text
schemaVersionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus