{-# 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.Schemas.DescribeSchema
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieve the schema definition.
module Amazonka.Schemas.DescribeSchema
  ( -- * Creating a Request
    DescribeSchema (..),
    newDescribeSchema,

    -- * Request Lenses
    describeSchema_schemaVersion,
    describeSchema_registryName,
    describeSchema_schemaName,

    -- * Destructuring the Response
    DescribeSchemaResponse (..),
    newDescribeSchemaResponse,

    -- * Response Lenses
    describeSchemaResponse_content,
    describeSchemaResponse_description,
    describeSchemaResponse_lastModified,
    describeSchemaResponse_schemaArn,
    describeSchemaResponse_schemaName,
    describeSchemaResponse_schemaVersion,
    describeSchemaResponse_tags,
    describeSchemaResponse_type,
    describeSchemaResponse_versionCreatedDate,
    describeSchemaResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDescribeSchema' smart constructor.
data DescribeSchema = DescribeSchema'
  { -- | Specifying this limits the results to only this schema version.
    DescribeSchema -> Maybe Text
schemaVersion :: Prelude.Maybe Prelude.Text,
    -- | The name of the registry.
    DescribeSchema -> Text
registryName :: Prelude.Text,
    -- | The name of the schema.
    DescribeSchema -> Text
schemaName :: Prelude.Text
  }
  deriving (DescribeSchema -> DescribeSchema -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeSchema -> DescribeSchema -> Bool
$c/= :: DescribeSchema -> DescribeSchema -> Bool
== :: DescribeSchema -> DescribeSchema -> Bool
$c== :: DescribeSchema -> DescribeSchema -> Bool
Prelude.Eq, ReadPrec [DescribeSchema]
ReadPrec DescribeSchema
Int -> ReadS DescribeSchema
ReadS [DescribeSchema]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeSchema]
$creadListPrec :: ReadPrec [DescribeSchema]
readPrec :: ReadPrec DescribeSchema
$creadPrec :: ReadPrec DescribeSchema
readList :: ReadS [DescribeSchema]
$creadList :: ReadS [DescribeSchema]
readsPrec :: Int -> ReadS DescribeSchema
$creadsPrec :: Int -> ReadS DescribeSchema
Prelude.Read, Int -> DescribeSchema -> ShowS
[DescribeSchema] -> ShowS
DescribeSchema -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeSchema] -> ShowS
$cshowList :: [DescribeSchema] -> ShowS
show :: DescribeSchema -> String
$cshow :: DescribeSchema -> String
showsPrec :: Int -> DescribeSchema -> ShowS
$cshowsPrec :: Int -> DescribeSchema -> ShowS
Prelude.Show, forall x. Rep DescribeSchema x -> DescribeSchema
forall x. DescribeSchema -> Rep DescribeSchema x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeSchema x -> DescribeSchema
$cfrom :: forall x. DescribeSchema -> Rep DescribeSchema x
Prelude.Generic)

-- |
-- Create a value of 'DescribeSchema' 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:
--
-- 'schemaVersion', 'describeSchema_schemaVersion' - Specifying this limits the results to only this schema version.
--
-- 'registryName', 'describeSchema_registryName' - The name of the registry.
--
-- 'schemaName', 'describeSchema_schemaName' - The name of the schema.
newDescribeSchema ::
  -- | 'registryName'
  Prelude.Text ->
  -- | 'schemaName'
  Prelude.Text ->
  DescribeSchema
newDescribeSchema :: Text -> Text -> DescribeSchema
newDescribeSchema Text
pRegistryName_ Text
pSchemaName_ =
  DescribeSchema'
    { $sel:schemaVersion:DescribeSchema' :: Maybe Text
schemaVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:registryName:DescribeSchema' :: Text
registryName = Text
pRegistryName_,
      $sel:schemaName:DescribeSchema' :: Text
schemaName = Text
pSchemaName_
    }

-- | Specifying this limits the results to only this schema version.
describeSchema_schemaVersion :: Lens.Lens' DescribeSchema (Prelude.Maybe Prelude.Text)
describeSchema_schemaVersion :: Lens' DescribeSchema (Maybe Text)
describeSchema_schemaVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchema' {Maybe Text
schemaVersion :: Maybe Text
$sel:schemaVersion:DescribeSchema' :: DescribeSchema -> Maybe Text
schemaVersion} -> Maybe Text
schemaVersion) (\s :: DescribeSchema
s@DescribeSchema' {} Maybe Text
a -> DescribeSchema
s {$sel:schemaVersion:DescribeSchema' :: Maybe Text
schemaVersion = Maybe Text
a} :: DescribeSchema)

-- | The name of the registry.
describeSchema_registryName :: Lens.Lens' DescribeSchema Prelude.Text
describeSchema_registryName :: Lens' DescribeSchema Text
describeSchema_registryName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchema' {Text
registryName :: Text
$sel:registryName:DescribeSchema' :: DescribeSchema -> Text
registryName} -> Text
registryName) (\s :: DescribeSchema
s@DescribeSchema' {} Text
a -> DescribeSchema
s {$sel:registryName:DescribeSchema' :: Text
registryName = Text
a} :: DescribeSchema)

-- | The name of the schema.
describeSchema_schemaName :: Lens.Lens' DescribeSchema Prelude.Text
describeSchema_schemaName :: Lens' DescribeSchema Text
describeSchema_schemaName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchema' {Text
schemaName :: Text
$sel:schemaName:DescribeSchema' :: DescribeSchema -> Text
schemaName} -> Text
schemaName) (\s :: DescribeSchema
s@DescribeSchema' {} Text
a -> DescribeSchema
s {$sel:schemaName:DescribeSchema' :: Text
schemaName = Text
a} :: DescribeSchema)

instance Core.AWSRequest DescribeSchema where
  type
    AWSResponse DescribeSchema =
      DescribeSchemaResponse
  request :: (Service -> Service) -> DescribeSchema -> Request DescribeSchema
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DescribeSchema
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DescribeSchema)))
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 Text
-> Maybe ISO8601
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Maybe ISO8601
-> Int
-> DescribeSchemaResponse
DescribeSchemaResponse'
            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
"Content")
            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
"Description")
            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
"LastModified")
            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
"SchemaArn")
            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
"SchemaName")
            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
"SchemaVersion")
            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
"tags" 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
"Type")
            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
"VersionCreatedDate")
            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 DescribeSchema where
  hashWithSalt :: Int -> DescribeSchema -> Int
hashWithSalt Int
_salt DescribeSchema' {Maybe Text
Text
schemaName :: Text
registryName :: Text
schemaVersion :: Maybe Text
$sel:schemaName:DescribeSchema' :: DescribeSchema -> Text
$sel:registryName:DescribeSchema' :: DescribeSchema -> Text
$sel:schemaVersion:DescribeSchema' :: DescribeSchema -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
schemaVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
registryName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
schemaName

instance Prelude.NFData DescribeSchema where
  rnf :: DescribeSchema -> ()
rnf DescribeSchema' {Maybe Text
Text
schemaName :: Text
registryName :: Text
schemaVersion :: Maybe Text
$sel:schemaName:DescribeSchema' :: DescribeSchema -> Text
$sel:registryName:DescribeSchema' :: DescribeSchema -> Text
$sel:schemaVersion:DescribeSchema' :: DescribeSchema -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
schemaVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
registryName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
schemaName

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

instance Data.ToPath DescribeSchema where
  toPath :: DescribeSchema -> ByteString
toPath DescribeSchema' {Maybe Text
Text
schemaName :: Text
registryName :: Text
schemaVersion :: Maybe Text
$sel:schemaName:DescribeSchema' :: DescribeSchema -> Text
$sel:registryName:DescribeSchema' :: DescribeSchema -> Text
$sel:schemaVersion:DescribeSchema' :: DescribeSchema -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/v1/registries/name/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
registryName,
        ByteString
"/schemas/name/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
schemaName
      ]

instance Data.ToQuery DescribeSchema where
  toQuery :: DescribeSchema -> QueryString
toQuery DescribeSchema' {Maybe Text
Text
schemaName :: Text
registryName :: Text
schemaVersion :: Maybe Text
$sel:schemaName:DescribeSchema' :: DescribeSchema -> Text
$sel:registryName:DescribeSchema' :: DescribeSchema -> Text
$sel:schemaVersion:DescribeSchema' :: DescribeSchema -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"schemaVersion" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
schemaVersion]

-- | /See:/ 'newDescribeSchemaResponse' smart constructor.
data DescribeSchemaResponse = DescribeSchemaResponse'
  { -- | The source of the schema definition.
    DescribeSchemaResponse -> Maybe Text
content :: Prelude.Maybe Prelude.Text,
    -- | The description of the schema.
    DescribeSchemaResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The date and time that schema was modified.
    DescribeSchemaResponse -> Maybe ISO8601
lastModified :: Prelude.Maybe Data.ISO8601,
    -- | The ARN of the schema.
    DescribeSchemaResponse -> Maybe Text
schemaArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the schema.
    DescribeSchemaResponse -> Maybe Text
schemaName :: Prelude.Maybe Prelude.Text,
    -- | The version number of the schema
    DescribeSchemaResponse -> Maybe Text
schemaVersion :: Prelude.Maybe Prelude.Text,
    -- | Tags associated with the resource.
    DescribeSchemaResponse -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The type of the schema.
    DescribeSchemaResponse -> Maybe Text
type' :: Prelude.Maybe Prelude.Text,
    -- | The date the schema version was created.
    DescribeSchemaResponse -> Maybe ISO8601
versionCreatedDate :: Prelude.Maybe Data.ISO8601,
    -- | The response's http status code.
    DescribeSchemaResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeSchemaResponse -> DescribeSchemaResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeSchemaResponse -> DescribeSchemaResponse -> Bool
$c/= :: DescribeSchemaResponse -> DescribeSchemaResponse -> Bool
== :: DescribeSchemaResponse -> DescribeSchemaResponse -> Bool
$c== :: DescribeSchemaResponse -> DescribeSchemaResponse -> Bool
Prelude.Eq, ReadPrec [DescribeSchemaResponse]
ReadPrec DescribeSchemaResponse
Int -> ReadS DescribeSchemaResponse
ReadS [DescribeSchemaResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeSchemaResponse]
$creadListPrec :: ReadPrec [DescribeSchemaResponse]
readPrec :: ReadPrec DescribeSchemaResponse
$creadPrec :: ReadPrec DescribeSchemaResponse
readList :: ReadS [DescribeSchemaResponse]
$creadList :: ReadS [DescribeSchemaResponse]
readsPrec :: Int -> ReadS DescribeSchemaResponse
$creadsPrec :: Int -> ReadS DescribeSchemaResponse
Prelude.Read, Int -> DescribeSchemaResponse -> ShowS
[DescribeSchemaResponse] -> ShowS
DescribeSchemaResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeSchemaResponse] -> ShowS
$cshowList :: [DescribeSchemaResponse] -> ShowS
show :: DescribeSchemaResponse -> String
$cshow :: DescribeSchemaResponse -> String
showsPrec :: Int -> DescribeSchemaResponse -> ShowS
$cshowsPrec :: Int -> DescribeSchemaResponse -> ShowS
Prelude.Show, forall x. Rep DescribeSchemaResponse x -> DescribeSchemaResponse
forall x. DescribeSchemaResponse -> Rep DescribeSchemaResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeSchemaResponse x -> DescribeSchemaResponse
$cfrom :: forall x. DescribeSchemaResponse -> Rep DescribeSchemaResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeSchemaResponse' 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:
--
-- 'content', 'describeSchemaResponse_content' - The source of the schema definition.
--
-- 'description', 'describeSchemaResponse_description' - The description of the schema.
--
-- 'lastModified', 'describeSchemaResponse_lastModified' - The date and time that schema was modified.
--
-- 'schemaArn', 'describeSchemaResponse_schemaArn' - The ARN of the schema.
--
-- 'schemaName', 'describeSchemaResponse_schemaName' - The name of the schema.
--
-- 'schemaVersion', 'describeSchemaResponse_schemaVersion' - The version number of the schema
--
-- 'tags', 'describeSchemaResponse_tags' - Tags associated with the resource.
--
-- 'type'', 'describeSchemaResponse_type' - The type of the schema.
--
-- 'versionCreatedDate', 'describeSchemaResponse_versionCreatedDate' - The date the schema version was created.
--
-- 'httpStatus', 'describeSchemaResponse_httpStatus' - The response's http status code.
newDescribeSchemaResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeSchemaResponse
newDescribeSchemaResponse :: Int -> DescribeSchemaResponse
newDescribeSchemaResponse Int
pHttpStatus_ =
  DescribeSchemaResponse'
    { $sel:content:DescribeSchemaResponse' :: Maybe Text
content = forall a. Maybe a
Prelude.Nothing,
      $sel:description:DescribeSchemaResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModified:DescribeSchemaResponse' :: Maybe ISO8601
lastModified = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaArn:DescribeSchemaResponse' :: Maybe Text
schemaArn = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaName:DescribeSchemaResponse' :: Maybe Text
schemaName = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaVersion:DescribeSchemaResponse' :: Maybe Text
schemaVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:DescribeSchemaResponse' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:type':DescribeSchemaResponse' :: Maybe Text
type' = forall a. Maybe a
Prelude.Nothing,
      $sel:versionCreatedDate:DescribeSchemaResponse' :: Maybe ISO8601
versionCreatedDate = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeSchemaResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The source of the schema definition.
describeSchemaResponse_content :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.Text)
describeSchemaResponse_content :: Lens' DescribeSchemaResponse (Maybe Text)
describeSchemaResponse_content = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe Text
content :: Maybe Text
$sel:content:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
content} -> Maybe Text
content) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe Text
a -> DescribeSchemaResponse
s {$sel:content:DescribeSchemaResponse' :: Maybe Text
content = Maybe Text
a} :: DescribeSchemaResponse)

-- | The description of the schema.
describeSchemaResponse_description :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.Text)
describeSchemaResponse_description :: Lens' DescribeSchemaResponse (Maybe Text)
describeSchemaResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe Text
description :: Maybe Text
$sel:description:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe Text
a -> DescribeSchemaResponse
s {$sel:description:DescribeSchemaResponse' :: Maybe Text
description = Maybe Text
a} :: DescribeSchemaResponse)

-- | The date and time that schema was modified.
describeSchemaResponse_lastModified :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.UTCTime)
describeSchemaResponse_lastModified :: Lens' DescribeSchemaResponse (Maybe UTCTime)
describeSchemaResponse_lastModified = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe ISO8601
lastModified :: Maybe ISO8601
$sel:lastModified:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe ISO8601
lastModified} -> Maybe ISO8601
lastModified) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe ISO8601
a -> DescribeSchemaResponse
s {$sel:lastModified:DescribeSchemaResponse' :: Maybe ISO8601
lastModified = Maybe ISO8601
a} :: DescribeSchemaResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The ARN of the schema.
describeSchemaResponse_schemaArn :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.Text)
describeSchemaResponse_schemaArn :: Lens' DescribeSchemaResponse (Maybe Text)
describeSchemaResponse_schemaArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe Text
schemaArn :: Maybe Text
$sel:schemaArn:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
schemaArn} -> Maybe Text
schemaArn) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe Text
a -> DescribeSchemaResponse
s {$sel:schemaArn:DescribeSchemaResponse' :: Maybe Text
schemaArn = Maybe Text
a} :: DescribeSchemaResponse)

-- | The name of the schema.
describeSchemaResponse_schemaName :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.Text)
describeSchemaResponse_schemaName :: Lens' DescribeSchemaResponse (Maybe Text)
describeSchemaResponse_schemaName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe Text
schemaName :: Maybe Text
$sel:schemaName:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
schemaName} -> Maybe Text
schemaName) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe Text
a -> DescribeSchemaResponse
s {$sel:schemaName:DescribeSchemaResponse' :: Maybe Text
schemaName = Maybe Text
a} :: DescribeSchemaResponse)

-- | The version number of the schema
describeSchemaResponse_schemaVersion :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.Text)
describeSchemaResponse_schemaVersion :: Lens' DescribeSchemaResponse (Maybe Text)
describeSchemaResponse_schemaVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe Text
schemaVersion :: Maybe Text
$sel:schemaVersion:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
schemaVersion} -> Maybe Text
schemaVersion) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe Text
a -> DescribeSchemaResponse
s {$sel:schemaVersion:DescribeSchemaResponse' :: Maybe Text
schemaVersion = Maybe Text
a} :: DescribeSchemaResponse)

-- | Tags associated with the resource.
describeSchemaResponse_tags :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
describeSchemaResponse_tags :: Lens' DescribeSchemaResponse (Maybe (HashMap Text Text))
describeSchemaResponse_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe (HashMap Text Text)
a -> DescribeSchemaResponse
s {$sel:tags:DescribeSchemaResponse' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: DescribeSchemaResponse) 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 type of the schema.
describeSchemaResponse_type :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.Text)
describeSchemaResponse_type :: Lens' DescribeSchemaResponse (Maybe Text)
describeSchemaResponse_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe Text
type' :: Maybe Text
$sel:type':DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
type'} -> Maybe Text
type') (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe Text
a -> DescribeSchemaResponse
s {$sel:type':DescribeSchemaResponse' :: Maybe Text
type' = Maybe Text
a} :: DescribeSchemaResponse)

-- | The date the schema version was created.
describeSchemaResponse_versionCreatedDate :: Lens.Lens' DescribeSchemaResponse (Prelude.Maybe Prelude.UTCTime)
describeSchemaResponse_versionCreatedDate :: Lens' DescribeSchemaResponse (Maybe UTCTime)
describeSchemaResponse_versionCreatedDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSchemaResponse' {Maybe ISO8601
versionCreatedDate :: Maybe ISO8601
$sel:versionCreatedDate:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe ISO8601
versionCreatedDate} -> Maybe ISO8601
versionCreatedDate) (\s :: DescribeSchemaResponse
s@DescribeSchemaResponse' {} Maybe ISO8601
a -> DescribeSchemaResponse
s {$sel:versionCreatedDate:DescribeSchemaResponse' :: Maybe ISO8601
versionCreatedDate = Maybe ISO8601
a} :: DescribeSchemaResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

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

instance Prelude.NFData DescribeSchemaResponse where
  rnf :: DescribeSchemaResponse -> ()
rnf DescribeSchemaResponse' {Int
Maybe Text
Maybe (HashMap Text Text)
Maybe ISO8601
httpStatus :: Int
versionCreatedDate :: Maybe ISO8601
type' :: Maybe Text
tags :: Maybe (HashMap Text Text)
schemaVersion :: Maybe Text
schemaName :: Maybe Text
schemaArn :: Maybe Text
lastModified :: Maybe ISO8601
description :: Maybe Text
content :: Maybe Text
$sel:httpStatus:DescribeSchemaResponse' :: DescribeSchemaResponse -> Int
$sel:versionCreatedDate:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe ISO8601
$sel:type':DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
$sel:tags:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe (HashMap Text Text)
$sel:schemaVersion:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
$sel:schemaName:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
$sel:schemaArn:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
$sel:lastModified:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe ISO8601
$sel:description:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
$sel:content:DescribeSchemaResponse' :: DescribeSchemaResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
content
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
lastModified
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
schemaArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
schemaName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
schemaVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
versionCreatedDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus