{-# 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.RegisterSchemaVersion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Adds a new version to the existing schema. Returns an error if new
-- version of schema does not meet the compatibility requirements of the
-- schema set. This API will not create a new schema set and will return a
-- 404 error if the schema set is not already present in the Schema
-- Registry.
--
-- If this is the first schema definition to be registered in the Schema
-- Registry, this API will store the schema version and return immediately.
-- Otherwise, this call has the potential to run longer than other
-- operations due to compatibility modes. You can call the
-- @GetSchemaVersion@ API with the @SchemaVersionId@ to check compatibility
-- modes.
--
-- If the same schema definition is already stored in Schema Registry as a
-- version, the schema ID of the existing schema is returned to the caller.
module Amazonka.Glue.RegisterSchemaVersion
  ( -- * Creating a Request
    RegisterSchemaVersion (..),
    newRegisterSchemaVersion,

    -- * Request Lenses
    registerSchemaVersion_schemaId,
    registerSchemaVersion_schemaDefinition,

    -- * Destructuring the Response
    RegisterSchemaVersionResponse (..),
    newRegisterSchemaVersionResponse,

    -- * Response Lenses
    registerSchemaVersionResponse_schemaVersionId,
    registerSchemaVersionResponse_status,
    registerSchemaVersionResponse_versionNumber,
    registerSchemaVersionResponse_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:/ 'newRegisterSchemaVersion' smart constructor.
data RegisterSchemaVersion = RegisterSchemaVersion'
  { -- | This is a wrapper structure to contain schema identity fields. The
    -- structure contains:
    --
    -- -   SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
    --     Either @SchemaArn@ or @SchemaName@ and @RegistryName@ has to be
    --     provided.
    --
    -- -   SchemaId$SchemaName: The name of the schema. Either @SchemaArn@ or
    --     @SchemaName@ and @RegistryName@ has to be provided.
    RegisterSchemaVersion -> SchemaId
schemaId :: SchemaId,
    -- | The schema definition using the @DataFormat@ setting for the
    -- @SchemaName@.
    RegisterSchemaVersion -> Text
schemaDefinition :: Prelude.Text
  }
  deriving (RegisterSchemaVersion -> RegisterSchemaVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterSchemaVersion -> RegisterSchemaVersion -> Bool
$c/= :: RegisterSchemaVersion -> RegisterSchemaVersion -> Bool
== :: RegisterSchemaVersion -> RegisterSchemaVersion -> Bool
$c== :: RegisterSchemaVersion -> RegisterSchemaVersion -> Bool
Prelude.Eq, ReadPrec [RegisterSchemaVersion]
ReadPrec RegisterSchemaVersion
Int -> ReadS RegisterSchemaVersion
ReadS [RegisterSchemaVersion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterSchemaVersion]
$creadListPrec :: ReadPrec [RegisterSchemaVersion]
readPrec :: ReadPrec RegisterSchemaVersion
$creadPrec :: ReadPrec RegisterSchemaVersion
readList :: ReadS [RegisterSchemaVersion]
$creadList :: ReadS [RegisterSchemaVersion]
readsPrec :: Int -> ReadS RegisterSchemaVersion
$creadsPrec :: Int -> ReadS RegisterSchemaVersion
Prelude.Read, Int -> RegisterSchemaVersion -> ShowS
[RegisterSchemaVersion] -> ShowS
RegisterSchemaVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterSchemaVersion] -> ShowS
$cshowList :: [RegisterSchemaVersion] -> ShowS
show :: RegisterSchemaVersion -> String
$cshow :: RegisterSchemaVersion -> String
showsPrec :: Int -> RegisterSchemaVersion -> ShowS
$cshowsPrec :: Int -> RegisterSchemaVersion -> ShowS
Prelude.Show, forall x. Rep RegisterSchemaVersion x -> RegisterSchemaVersion
forall x. RegisterSchemaVersion -> Rep RegisterSchemaVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegisterSchemaVersion x -> RegisterSchemaVersion
$cfrom :: forall x. RegisterSchemaVersion -> Rep RegisterSchemaVersion x
Prelude.Generic)

-- |
-- Create a value of 'RegisterSchemaVersion' 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:
--
-- 'schemaId', 'registerSchemaVersion_schemaId' - This is a wrapper structure to contain schema identity fields. The
-- structure contains:
--
-- -   SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
--     Either @SchemaArn@ or @SchemaName@ and @RegistryName@ has to be
--     provided.
--
-- -   SchemaId$SchemaName: The name of the schema. Either @SchemaArn@ or
--     @SchemaName@ and @RegistryName@ has to be provided.
--
-- 'schemaDefinition', 'registerSchemaVersion_schemaDefinition' - The schema definition using the @DataFormat@ setting for the
-- @SchemaName@.
newRegisterSchemaVersion ::
  -- | 'schemaId'
  SchemaId ->
  -- | 'schemaDefinition'
  Prelude.Text ->
  RegisterSchemaVersion
newRegisterSchemaVersion :: SchemaId -> Text -> RegisterSchemaVersion
newRegisterSchemaVersion
  SchemaId
pSchemaId_
  Text
pSchemaDefinition_ =
    RegisterSchemaVersion'
      { $sel:schemaId:RegisterSchemaVersion' :: SchemaId
schemaId = SchemaId
pSchemaId_,
        $sel:schemaDefinition:RegisterSchemaVersion' :: Text
schemaDefinition = Text
pSchemaDefinition_
      }

-- | This is a wrapper structure to contain schema identity fields. The
-- structure contains:
--
-- -   SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
--     Either @SchemaArn@ or @SchemaName@ and @RegistryName@ has to be
--     provided.
--
-- -   SchemaId$SchemaName: The name of the schema. Either @SchemaArn@ or
--     @SchemaName@ and @RegistryName@ has to be provided.
registerSchemaVersion_schemaId :: Lens.Lens' RegisterSchemaVersion SchemaId
registerSchemaVersion_schemaId :: Lens' RegisterSchemaVersion SchemaId
registerSchemaVersion_schemaId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterSchemaVersion' {SchemaId
schemaId :: SchemaId
$sel:schemaId:RegisterSchemaVersion' :: RegisterSchemaVersion -> SchemaId
schemaId} -> SchemaId
schemaId) (\s :: RegisterSchemaVersion
s@RegisterSchemaVersion' {} SchemaId
a -> RegisterSchemaVersion
s {$sel:schemaId:RegisterSchemaVersion' :: SchemaId
schemaId = SchemaId
a} :: RegisterSchemaVersion)

-- | The schema definition using the @DataFormat@ setting for the
-- @SchemaName@.
registerSchemaVersion_schemaDefinition :: Lens.Lens' RegisterSchemaVersion Prelude.Text
registerSchemaVersion_schemaDefinition :: Lens' RegisterSchemaVersion Text
registerSchemaVersion_schemaDefinition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterSchemaVersion' {Text
schemaDefinition :: Text
$sel:schemaDefinition:RegisterSchemaVersion' :: RegisterSchemaVersion -> Text
schemaDefinition} -> Text
schemaDefinition) (\s :: RegisterSchemaVersion
s@RegisterSchemaVersion' {} Text
a -> RegisterSchemaVersion
s {$sel:schemaDefinition:RegisterSchemaVersion' :: Text
schemaDefinition = Text
a} :: RegisterSchemaVersion)

instance Core.AWSRequest RegisterSchemaVersion where
  type
    AWSResponse RegisterSchemaVersion =
      RegisterSchemaVersionResponse
  request :: (Service -> Service)
-> RegisterSchemaVersion -> Request RegisterSchemaVersion
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 RegisterSchemaVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RegisterSchemaVersion)))
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 SchemaVersionStatus
-> Maybe Natural
-> Int
-> RegisterSchemaVersionResponse
RegisterSchemaVersionResponse'
            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
"SchemaVersionId")
            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
"Status")
            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
"VersionNumber")
            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 RegisterSchemaVersion where
  hashWithSalt :: Int -> RegisterSchemaVersion -> Int
hashWithSalt Int
_salt RegisterSchemaVersion' {Text
SchemaId
schemaDefinition :: Text
schemaId :: SchemaId
$sel:schemaDefinition:RegisterSchemaVersion' :: RegisterSchemaVersion -> Text
$sel:schemaId:RegisterSchemaVersion' :: RegisterSchemaVersion -> SchemaId
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SchemaId
schemaId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
schemaDefinition

instance Prelude.NFData RegisterSchemaVersion where
  rnf :: RegisterSchemaVersion -> ()
rnf RegisterSchemaVersion' {Text
SchemaId
schemaDefinition :: Text
schemaId :: SchemaId
$sel:schemaDefinition:RegisterSchemaVersion' :: RegisterSchemaVersion -> Text
$sel:schemaId:RegisterSchemaVersion' :: RegisterSchemaVersion -> SchemaId
..} =
    forall a. NFData a => a -> ()
Prelude.rnf SchemaId
schemaId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
schemaDefinition

instance Data.ToHeaders RegisterSchemaVersion where
  toHeaders :: RegisterSchemaVersion -> 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.RegisterSchemaVersion" ::
                          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 RegisterSchemaVersion where
  toJSON :: RegisterSchemaVersion -> Value
toJSON RegisterSchemaVersion' {Text
SchemaId
schemaDefinition :: Text
schemaId :: SchemaId
$sel:schemaDefinition:RegisterSchemaVersion' :: RegisterSchemaVersion -> Text
$sel:schemaId:RegisterSchemaVersion' :: RegisterSchemaVersion -> SchemaId
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"SchemaId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SchemaId
schemaId),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"SchemaDefinition" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
schemaDefinition)
          ]
      )

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

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

-- | /See:/ 'newRegisterSchemaVersionResponse' smart constructor.
data RegisterSchemaVersionResponse = RegisterSchemaVersionResponse'
  { -- | The unique ID that represents the version of this schema.
    RegisterSchemaVersionResponse -> Maybe Text
schemaVersionId :: Prelude.Maybe Prelude.Text,
    -- | The status of the schema version.
    RegisterSchemaVersionResponse -> Maybe SchemaVersionStatus
status :: Prelude.Maybe SchemaVersionStatus,
    -- | The version of this schema (for sync flow only, in case this is the
    -- first version).
    RegisterSchemaVersionResponse -> Maybe Natural
versionNumber :: Prelude.Maybe Prelude.Natural,
    -- | The response's http status code.
    RegisterSchemaVersionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RegisterSchemaVersionResponse
-> RegisterSchemaVersionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterSchemaVersionResponse
-> RegisterSchemaVersionResponse -> Bool
$c/= :: RegisterSchemaVersionResponse
-> RegisterSchemaVersionResponse -> Bool
== :: RegisterSchemaVersionResponse
-> RegisterSchemaVersionResponse -> Bool
$c== :: RegisterSchemaVersionResponse
-> RegisterSchemaVersionResponse -> Bool
Prelude.Eq, ReadPrec [RegisterSchemaVersionResponse]
ReadPrec RegisterSchemaVersionResponse
Int -> ReadS RegisterSchemaVersionResponse
ReadS [RegisterSchemaVersionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterSchemaVersionResponse]
$creadListPrec :: ReadPrec [RegisterSchemaVersionResponse]
readPrec :: ReadPrec RegisterSchemaVersionResponse
$creadPrec :: ReadPrec RegisterSchemaVersionResponse
readList :: ReadS [RegisterSchemaVersionResponse]
$creadList :: ReadS [RegisterSchemaVersionResponse]
readsPrec :: Int -> ReadS RegisterSchemaVersionResponse
$creadsPrec :: Int -> ReadS RegisterSchemaVersionResponse
Prelude.Read, Int -> RegisterSchemaVersionResponse -> ShowS
[RegisterSchemaVersionResponse] -> ShowS
RegisterSchemaVersionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterSchemaVersionResponse] -> ShowS
$cshowList :: [RegisterSchemaVersionResponse] -> ShowS
show :: RegisterSchemaVersionResponse -> String
$cshow :: RegisterSchemaVersionResponse -> String
showsPrec :: Int -> RegisterSchemaVersionResponse -> ShowS
$cshowsPrec :: Int -> RegisterSchemaVersionResponse -> ShowS
Prelude.Show, forall x.
Rep RegisterSchemaVersionResponse x
-> RegisterSchemaVersionResponse
forall x.
RegisterSchemaVersionResponse
-> Rep RegisterSchemaVersionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RegisterSchemaVersionResponse x
-> RegisterSchemaVersionResponse
$cfrom :: forall x.
RegisterSchemaVersionResponse
-> Rep RegisterSchemaVersionResponse x
Prelude.Generic)

-- |
-- Create a value of 'RegisterSchemaVersionResponse' 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:
--
-- 'schemaVersionId', 'registerSchemaVersionResponse_schemaVersionId' - The unique ID that represents the version of this schema.
--
-- 'status', 'registerSchemaVersionResponse_status' - The status of the schema version.
--
-- 'versionNumber', 'registerSchemaVersionResponse_versionNumber' - The version of this schema (for sync flow only, in case this is the
-- first version).
--
-- 'httpStatus', 'registerSchemaVersionResponse_httpStatus' - The response's http status code.
newRegisterSchemaVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RegisterSchemaVersionResponse
newRegisterSchemaVersionResponse :: Int -> RegisterSchemaVersionResponse
newRegisterSchemaVersionResponse Int
pHttpStatus_ =
  RegisterSchemaVersionResponse'
    { $sel:schemaVersionId:RegisterSchemaVersionResponse' :: Maybe Text
schemaVersionId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:status:RegisterSchemaVersionResponse' :: Maybe SchemaVersionStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:versionNumber:RegisterSchemaVersionResponse' :: Maybe Natural
versionNumber = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RegisterSchemaVersionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

-- | The status of the schema version.
registerSchemaVersionResponse_status :: Lens.Lens' RegisterSchemaVersionResponse (Prelude.Maybe SchemaVersionStatus)
registerSchemaVersionResponse_status :: Lens' RegisterSchemaVersionResponse (Maybe SchemaVersionStatus)
registerSchemaVersionResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterSchemaVersionResponse' {Maybe SchemaVersionStatus
status :: Maybe SchemaVersionStatus
$sel:status:RegisterSchemaVersionResponse' :: RegisterSchemaVersionResponse -> Maybe SchemaVersionStatus
status} -> Maybe SchemaVersionStatus
status) (\s :: RegisterSchemaVersionResponse
s@RegisterSchemaVersionResponse' {} Maybe SchemaVersionStatus
a -> RegisterSchemaVersionResponse
s {$sel:status:RegisterSchemaVersionResponse' :: Maybe SchemaVersionStatus
status = Maybe SchemaVersionStatus
a} :: RegisterSchemaVersionResponse)

-- | The version of this schema (for sync flow only, in case this is the
-- first version).
registerSchemaVersionResponse_versionNumber :: Lens.Lens' RegisterSchemaVersionResponse (Prelude.Maybe Prelude.Natural)
registerSchemaVersionResponse_versionNumber :: Lens' RegisterSchemaVersionResponse (Maybe Natural)
registerSchemaVersionResponse_versionNumber = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterSchemaVersionResponse' {Maybe Natural
versionNumber :: Maybe Natural
$sel:versionNumber:RegisterSchemaVersionResponse' :: RegisterSchemaVersionResponse -> Maybe Natural
versionNumber} -> Maybe Natural
versionNumber) (\s :: RegisterSchemaVersionResponse
s@RegisterSchemaVersionResponse' {} Maybe Natural
a -> RegisterSchemaVersionResponse
s {$sel:versionNumber:RegisterSchemaVersionResponse' :: Maybe Natural
versionNumber = Maybe Natural
a} :: RegisterSchemaVersionResponse)

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

instance Prelude.NFData RegisterSchemaVersionResponse where
  rnf :: RegisterSchemaVersionResponse -> ()
rnf RegisterSchemaVersionResponse' {Int
Maybe Natural
Maybe Text
Maybe SchemaVersionStatus
httpStatus :: Int
versionNumber :: Maybe Natural
status :: Maybe SchemaVersionStatus
schemaVersionId :: Maybe Text
$sel:httpStatus:RegisterSchemaVersionResponse' :: RegisterSchemaVersionResponse -> Int
$sel:versionNumber:RegisterSchemaVersionResponse' :: RegisterSchemaVersionResponse -> Maybe Natural
$sel:status:RegisterSchemaVersionResponse' :: RegisterSchemaVersionResponse -> Maybe SchemaVersionStatus
$sel:schemaVersionId:RegisterSchemaVersionResponse' :: RegisterSchemaVersionResponse -> Maybe Text
..} =
    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 SchemaVersionStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
versionNumber
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus