{-# 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.ExportSchema
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- -- | Undocumented operation.
module Amazonka.Schemas.ExportSchema
  ( -- * Creating a Request
    ExportSchema (..),
    newExportSchema,

    -- * Request Lenses
    exportSchema_schemaVersion,
    exportSchema_registryName,
    exportSchema_schemaName,
    exportSchema_type,

    -- * Destructuring the Response
    ExportSchemaResponse (..),
    newExportSchemaResponse,

    -- * Response Lenses
    exportSchemaResponse_schemaVersion,
    exportSchemaResponse_schemaName,
    exportSchemaResponse_content,
    exportSchemaResponse_schemaArn,
    exportSchemaResponse_type,
    exportSchemaResponse_httpStatus,
  )
where

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

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

-- |
-- Create a value of 'ExportSchema' 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', 'exportSchema_schemaVersion' - Specifying this limits the results to only this schema version.
--
-- 'registryName', 'exportSchema_registryName' - The name of the registry.
--
-- 'schemaName', 'exportSchema_schemaName' - The name of the schema.
--
-- 'type'', 'exportSchema_type' - Undocumented member.
newExportSchema ::
  -- | 'registryName'
  Prelude.Text ->
  -- | 'schemaName'
  Prelude.Text ->
  -- | 'type''
  Prelude.Text ->
  ExportSchema
newExportSchema :: Text -> Text -> Text -> ExportSchema
newExportSchema Text
pRegistryName_ Text
pSchemaName_ Text
pType_ =
  ExportSchema' :: Maybe Text -> Text -> Text -> Text -> ExportSchema
ExportSchema'
    { $sel:schemaVersion:ExportSchema' :: Maybe Text
schemaVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:registryName:ExportSchema' :: Text
registryName = Text
pRegistryName_,
      $sel:schemaName:ExportSchema' :: Text
schemaName = Text
pSchemaName_,
      $sel:type':ExportSchema' :: Text
type' = Text
pType_
    }

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

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

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

-- | Undocumented member.
exportSchema_type :: Lens.Lens' ExportSchema Prelude.Text
exportSchema_type :: (Text -> f Text) -> ExportSchema -> f ExportSchema
exportSchema_type = (ExportSchema -> Text)
-> (ExportSchema -> Text -> ExportSchema)
-> Lens ExportSchema ExportSchema Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExportSchema' {Text
type' :: Text
$sel:type':ExportSchema' :: ExportSchema -> Text
type'} -> Text
type') (\s :: ExportSchema
s@ExportSchema' {} Text
a -> ExportSchema
s {$sel:type':ExportSchema' :: Text
type' = Text
a} :: ExportSchema)

instance Core.AWSRequest ExportSchema where
  type AWSResponse ExportSchema = ExportSchemaResponse
  request :: ExportSchema -> Request ExportSchema
request = Service -> ExportSchema -> Request ExportSchema
forall a. ToRequest a => Service -> a -> Request a
Request.get Service
defaultService
  response :: Logger
-> Service
-> Proxy ExportSchema
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ExportSchema)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse ExportSchema))
-> Logger
-> Service
-> Proxy ExportSchema
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ExportSchema)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> ExportSchemaResponse
ExportSchemaResponse'
            (Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Int
 -> ExportSchemaResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Int
      -> ExportSchemaResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"SchemaVersion")
            Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Int
   -> ExportSchemaResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text -> Maybe Text -> Int -> ExportSchemaResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"SchemaName")
            Either
  String
  (Maybe Text
   -> Maybe Text -> Maybe Text -> Int -> ExportSchemaResponse)
-> Either String (Maybe Text)
-> Either
     String (Maybe Text -> Maybe Text -> Int -> ExportSchemaResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Content")
            Either
  String (Maybe Text -> Maybe Text -> Int -> ExportSchemaResponse)
-> Either String (Maybe Text)
-> Either String (Maybe Text -> Int -> ExportSchemaResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"SchemaArn")
            Either String (Maybe Text -> Int -> ExportSchemaResponse)
-> Either String (Maybe Text)
-> Either String (Int -> ExportSchemaResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Type")
            Either String (Int -> ExportSchemaResponse)
-> Either String Int -> Either String ExportSchemaResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ExportSchema

instance Prelude.NFData ExportSchema

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

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

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

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

-- |
-- Create a value of 'ExportSchemaResponse' 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', 'exportSchemaResponse_schemaVersion' - Undocumented member.
--
-- 'schemaName', 'exportSchemaResponse_schemaName' - Undocumented member.
--
-- 'content', 'exportSchemaResponse_content' - Undocumented member.
--
-- 'schemaArn', 'exportSchemaResponse_schemaArn' - Undocumented member.
--
-- 'type'', 'exportSchemaResponse_type' - Undocumented member.
--
-- 'httpStatus', 'exportSchemaResponse_httpStatus' - The response's http status code.
newExportSchemaResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ExportSchemaResponse
newExportSchemaResponse :: Int -> ExportSchemaResponse
newExportSchemaResponse Int
pHttpStatus_ =
  ExportSchemaResponse' :: Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> ExportSchemaResponse
ExportSchemaResponse'
    { $sel:schemaVersion:ExportSchemaResponse' :: Maybe Text
schemaVersion =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:schemaName:ExportSchemaResponse' :: Maybe Text
schemaName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:content:ExportSchemaResponse' :: Maybe Text
content = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:schemaArn:ExportSchemaResponse' :: Maybe Text
schemaArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:type':ExportSchemaResponse' :: Maybe Text
type' = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ExportSchemaResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
exportSchemaResponse_schemaVersion :: Lens.Lens' ExportSchemaResponse (Prelude.Maybe Prelude.Text)
exportSchemaResponse_schemaVersion :: (Maybe Text -> f (Maybe Text))
-> ExportSchemaResponse -> f ExportSchemaResponse
exportSchemaResponse_schemaVersion = (ExportSchemaResponse -> Maybe Text)
-> (ExportSchemaResponse -> Maybe Text -> ExportSchemaResponse)
-> Lens
     ExportSchemaResponse ExportSchemaResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExportSchemaResponse' {Maybe Text
schemaVersion :: Maybe Text
$sel:schemaVersion:ExportSchemaResponse' :: ExportSchemaResponse -> Maybe Text
schemaVersion} -> Maybe Text
schemaVersion) (\s :: ExportSchemaResponse
s@ExportSchemaResponse' {} Maybe Text
a -> ExportSchemaResponse
s {$sel:schemaVersion:ExportSchemaResponse' :: Maybe Text
schemaVersion = Maybe Text
a} :: ExportSchemaResponse)

-- | Undocumented member.
exportSchemaResponse_schemaName :: Lens.Lens' ExportSchemaResponse (Prelude.Maybe Prelude.Text)
exportSchemaResponse_schemaName :: (Maybe Text -> f (Maybe Text))
-> ExportSchemaResponse -> f ExportSchemaResponse
exportSchemaResponse_schemaName = (ExportSchemaResponse -> Maybe Text)
-> (ExportSchemaResponse -> Maybe Text -> ExportSchemaResponse)
-> Lens
     ExportSchemaResponse ExportSchemaResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExportSchemaResponse' {Maybe Text
schemaName :: Maybe Text
$sel:schemaName:ExportSchemaResponse' :: ExportSchemaResponse -> Maybe Text
schemaName} -> Maybe Text
schemaName) (\s :: ExportSchemaResponse
s@ExportSchemaResponse' {} Maybe Text
a -> ExportSchemaResponse
s {$sel:schemaName:ExportSchemaResponse' :: Maybe Text
schemaName = Maybe Text
a} :: ExportSchemaResponse)

-- | Undocumented member.
exportSchemaResponse_content :: Lens.Lens' ExportSchemaResponse (Prelude.Maybe Prelude.Text)
exportSchemaResponse_content :: (Maybe Text -> f (Maybe Text))
-> ExportSchemaResponse -> f ExportSchemaResponse
exportSchemaResponse_content = (ExportSchemaResponse -> Maybe Text)
-> (ExportSchemaResponse -> Maybe Text -> ExportSchemaResponse)
-> Lens
     ExportSchemaResponse ExportSchemaResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExportSchemaResponse' {Maybe Text
content :: Maybe Text
$sel:content:ExportSchemaResponse' :: ExportSchemaResponse -> Maybe Text
content} -> Maybe Text
content) (\s :: ExportSchemaResponse
s@ExportSchemaResponse' {} Maybe Text
a -> ExportSchemaResponse
s {$sel:content:ExportSchemaResponse' :: Maybe Text
content = Maybe Text
a} :: ExportSchemaResponse)

-- | Undocumented member.
exportSchemaResponse_schemaArn :: Lens.Lens' ExportSchemaResponse (Prelude.Maybe Prelude.Text)
exportSchemaResponse_schemaArn :: (Maybe Text -> f (Maybe Text))
-> ExportSchemaResponse -> f ExportSchemaResponse
exportSchemaResponse_schemaArn = (ExportSchemaResponse -> Maybe Text)
-> (ExportSchemaResponse -> Maybe Text -> ExportSchemaResponse)
-> Lens
     ExportSchemaResponse ExportSchemaResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExportSchemaResponse' {Maybe Text
schemaArn :: Maybe Text
$sel:schemaArn:ExportSchemaResponse' :: ExportSchemaResponse -> Maybe Text
schemaArn} -> Maybe Text
schemaArn) (\s :: ExportSchemaResponse
s@ExportSchemaResponse' {} Maybe Text
a -> ExportSchemaResponse
s {$sel:schemaArn:ExportSchemaResponse' :: Maybe Text
schemaArn = Maybe Text
a} :: ExportSchemaResponse)

-- | Undocumented member.
exportSchemaResponse_type :: Lens.Lens' ExportSchemaResponse (Prelude.Maybe Prelude.Text)
exportSchemaResponse_type :: (Maybe Text -> f (Maybe Text))
-> ExportSchemaResponse -> f ExportSchemaResponse
exportSchemaResponse_type = (ExportSchemaResponse -> Maybe Text)
-> (ExportSchemaResponse -> Maybe Text -> ExportSchemaResponse)
-> Lens
     ExportSchemaResponse ExportSchemaResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExportSchemaResponse' {Maybe Text
type' :: Maybe Text
$sel:type':ExportSchemaResponse' :: ExportSchemaResponse -> Maybe Text
type'} -> Maybe Text
type') (\s :: ExportSchemaResponse
s@ExportSchemaResponse' {} Maybe Text
a -> ExportSchemaResponse
s {$sel:type':ExportSchemaResponse' :: Maybe Text
type' = Maybe Text
a} :: ExportSchemaResponse)

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

instance Prelude.NFData ExportSchemaResponse