{-# 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.GetSchemaVersionsDiff
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Fetches the schema version difference in the specified difference type
-- between two stored schema versions in the Schema Registry.
--
-- This API allows you to compare two schema versions between two schema
-- definitions under the same schema.
module Amazonka.Glue.GetSchemaVersionsDiff
  ( -- * Creating a Request
    GetSchemaVersionsDiff (..),
    newGetSchemaVersionsDiff,

    -- * Request Lenses
    getSchemaVersionsDiff_schemaId,
    getSchemaVersionsDiff_firstSchemaVersionNumber,
    getSchemaVersionsDiff_secondSchemaVersionNumber,
    getSchemaVersionsDiff_schemaDiffType,

    -- * Destructuring the Response
    GetSchemaVersionsDiffResponse (..),
    newGetSchemaVersionsDiffResponse,

    -- * Response Lenses
    getSchemaVersionsDiffResponse_diff,
    getSchemaVersionsDiffResponse_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:/ 'newGetSchemaVersionsDiff' smart constructor.
data GetSchemaVersionsDiff = GetSchemaVersionsDiff'
  { -- | This is a wrapper structure to contain schema identity fields. The
    -- structure contains:
    --
    -- -   SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
    --     One of @SchemaArn@ or @SchemaName@ has to be provided.
    --
    -- -   SchemaId$SchemaName: The name of the schema. One of @SchemaArn@ or
    --     @SchemaName@ has to be provided.
    GetSchemaVersionsDiff -> SchemaId
schemaId :: SchemaId,
    -- | The first of the two schema versions to be compared.
    GetSchemaVersionsDiff -> SchemaVersionNumber
firstSchemaVersionNumber :: SchemaVersionNumber,
    -- | The second of the two schema versions to be compared.
    GetSchemaVersionsDiff -> SchemaVersionNumber
secondSchemaVersionNumber :: SchemaVersionNumber,
    -- | Refers to @SYNTAX_DIFF@, which is the currently supported diff type.
    GetSchemaVersionsDiff -> SchemaDiffType
schemaDiffType :: SchemaDiffType
  }
  deriving (GetSchemaVersionsDiff -> GetSchemaVersionsDiff -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetSchemaVersionsDiff -> GetSchemaVersionsDiff -> Bool
$c/= :: GetSchemaVersionsDiff -> GetSchemaVersionsDiff -> Bool
== :: GetSchemaVersionsDiff -> GetSchemaVersionsDiff -> Bool
$c== :: GetSchemaVersionsDiff -> GetSchemaVersionsDiff -> Bool
Prelude.Eq, ReadPrec [GetSchemaVersionsDiff]
ReadPrec GetSchemaVersionsDiff
Int -> ReadS GetSchemaVersionsDiff
ReadS [GetSchemaVersionsDiff]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetSchemaVersionsDiff]
$creadListPrec :: ReadPrec [GetSchemaVersionsDiff]
readPrec :: ReadPrec GetSchemaVersionsDiff
$creadPrec :: ReadPrec GetSchemaVersionsDiff
readList :: ReadS [GetSchemaVersionsDiff]
$creadList :: ReadS [GetSchemaVersionsDiff]
readsPrec :: Int -> ReadS GetSchemaVersionsDiff
$creadsPrec :: Int -> ReadS GetSchemaVersionsDiff
Prelude.Read, Int -> GetSchemaVersionsDiff -> ShowS
[GetSchemaVersionsDiff] -> ShowS
GetSchemaVersionsDiff -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetSchemaVersionsDiff] -> ShowS
$cshowList :: [GetSchemaVersionsDiff] -> ShowS
show :: GetSchemaVersionsDiff -> String
$cshow :: GetSchemaVersionsDiff -> String
showsPrec :: Int -> GetSchemaVersionsDiff -> ShowS
$cshowsPrec :: Int -> GetSchemaVersionsDiff -> ShowS
Prelude.Show, forall x. Rep GetSchemaVersionsDiff x -> GetSchemaVersionsDiff
forall x. GetSchemaVersionsDiff -> Rep GetSchemaVersionsDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetSchemaVersionsDiff x -> GetSchemaVersionsDiff
$cfrom :: forall x. GetSchemaVersionsDiff -> Rep GetSchemaVersionsDiff x
Prelude.Generic)

-- |
-- Create a value of 'GetSchemaVersionsDiff' 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', 'getSchemaVersionsDiff_schemaId' - This is a wrapper structure to contain schema identity fields. The
-- structure contains:
--
-- -   SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema.
--     One of @SchemaArn@ or @SchemaName@ has to be provided.
--
-- -   SchemaId$SchemaName: The name of the schema. One of @SchemaArn@ or
--     @SchemaName@ has to be provided.
--
-- 'firstSchemaVersionNumber', 'getSchemaVersionsDiff_firstSchemaVersionNumber' - The first of the two schema versions to be compared.
--
-- 'secondSchemaVersionNumber', 'getSchemaVersionsDiff_secondSchemaVersionNumber' - The second of the two schema versions to be compared.
--
-- 'schemaDiffType', 'getSchemaVersionsDiff_schemaDiffType' - Refers to @SYNTAX_DIFF@, which is the currently supported diff type.
newGetSchemaVersionsDiff ::
  -- | 'schemaId'
  SchemaId ->
  -- | 'firstSchemaVersionNumber'
  SchemaVersionNumber ->
  -- | 'secondSchemaVersionNumber'
  SchemaVersionNumber ->
  -- | 'schemaDiffType'
  SchemaDiffType ->
  GetSchemaVersionsDiff
newGetSchemaVersionsDiff :: SchemaId
-> SchemaVersionNumber
-> SchemaVersionNumber
-> SchemaDiffType
-> GetSchemaVersionsDiff
newGetSchemaVersionsDiff
  SchemaId
pSchemaId_
  SchemaVersionNumber
pFirstSchemaVersionNumber_
  SchemaVersionNumber
pSecondSchemaVersionNumber_
  SchemaDiffType
pSchemaDiffType_ =
    GetSchemaVersionsDiff'
      { $sel:schemaId:GetSchemaVersionsDiff' :: SchemaId
schemaId = SchemaId
pSchemaId_,
        $sel:firstSchemaVersionNumber:GetSchemaVersionsDiff' :: SchemaVersionNumber
firstSchemaVersionNumber =
          SchemaVersionNumber
pFirstSchemaVersionNumber_,
        $sel:secondSchemaVersionNumber:GetSchemaVersionsDiff' :: SchemaVersionNumber
secondSchemaVersionNumber =
          SchemaVersionNumber
pSecondSchemaVersionNumber_,
        $sel:schemaDiffType:GetSchemaVersionsDiff' :: SchemaDiffType
schemaDiffType = SchemaDiffType
pSchemaDiffType_
      }

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

-- | The first of the two schema versions to be compared.
getSchemaVersionsDiff_firstSchemaVersionNumber :: Lens.Lens' GetSchemaVersionsDiff SchemaVersionNumber
getSchemaVersionsDiff_firstSchemaVersionNumber :: Lens' GetSchemaVersionsDiff SchemaVersionNumber
getSchemaVersionsDiff_firstSchemaVersionNumber = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSchemaVersionsDiff' {SchemaVersionNumber
firstSchemaVersionNumber :: SchemaVersionNumber
$sel:firstSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
firstSchemaVersionNumber} -> SchemaVersionNumber
firstSchemaVersionNumber) (\s :: GetSchemaVersionsDiff
s@GetSchemaVersionsDiff' {} SchemaVersionNumber
a -> GetSchemaVersionsDiff
s {$sel:firstSchemaVersionNumber:GetSchemaVersionsDiff' :: SchemaVersionNumber
firstSchemaVersionNumber = SchemaVersionNumber
a} :: GetSchemaVersionsDiff)

-- | The second of the two schema versions to be compared.
getSchemaVersionsDiff_secondSchemaVersionNumber :: Lens.Lens' GetSchemaVersionsDiff SchemaVersionNumber
getSchemaVersionsDiff_secondSchemaVersionNumber :: Lens' GetSchemaVersionsDiff SchemaVersionNumber
getSchemaVersionsDiff_secondSchemaVersionNumber = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSchemaVersionsDiff' {SchemaVersionNumber
secondSchemaVersionNumber :: SchemaVersionNumber
$sel:secondSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
secondSchemaVersionNumber} -> SchemaVersionNumber
secondSchemaVersionNumber) (\s :: GetSchemaVersionsDiff
s@GetSchemaVersionsDiff' {} SchemaVersionNumber
a -> GetSchemaVersionsDiff
s {$sel:secondSchemaVersionNumber:GetSchemaVersionsDiff' :: SchemaVersionNumber
secondSchemaVersionNumber = SchemaVersionNumber
a} :: GetSchemaVersionsDiff)

-- | Refers to @SYNTAX_DIFF@, which is the currently supported diff type.
getSchemaVersionsDiff_schemaDiffType :: Lens.Lens' GetSchemaVersionsDiff SchemaDiffType
getSchemaVersionsDiff_schemaDiffType :: Lens' GetSchemaVersionsDiff SchemaDiffType
getSchemaVersionsDiff_schemaDiffType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSchemaVersionsDiff' {SchemaDiffType
schemaDiffType :: SchemaDiffType
$sel:schemaDiffType:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaDiffType
schemaDiffType} -> SchemaDiffType
schemaDiffType) (\s :: GetSchemaVersionsDiff
s@GetSchemaVersionsDiff' {} SchemaDiffType
a -> GetSchemaVersionsDiff
s {$sel:schemaDiffType:GetSchemaVersionsDiff' :: SchemaDiffType
schemaDiffType = SchemaDiffType
a} :: GetSchemaVersionsDiff)

instance Core.AWSRequest GetSchemaVersionsDiff where
  type
    AWSResponse GetSchemaVersionsDiff =
      GetSchemaVersionsDiffResponse
  request :: (Service -> Service)
-> GetSchemaVersionsDiff -> Request GetSchemaVersionsDiff
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 GetSchemaVersionsDiff
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetSchemaVersionsDiff)))
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 -> Int -> GetSchemaVersionsDiffResponse
GetSchemaVersionsDiffResponse'
            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
"Diff")
            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 GetSchemaVersionsDiff where
  hashWithSalt :: Int -> GetSchemaVersionsDiff -> Int
hashWithSalt Int
_salt GetSchemaVersionsDiff' {SchemaDiffType
SchemaId
SchemaVersionNumber
schemaDiffType :: SchemaDiffType
secondSchemaVersionNumber :: SchemaVersionNumber
firstSchemaVersionNumber :: SchemaVersionNumber
schemaId :: SchemaId
$sel:schemaDiffType:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaDiffType
$sel:secondSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
$sel:firstSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
$sel:schemaId:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaId
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SchemaId
schemaId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SchemaVersionNumber
firstSchemaVersionNumber
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SchemaVersionNumber
secondSchemaVersionNumber
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` SchemaDiffType
schemaDiffType

instance Prelude.NFData GetSchemaVersionsDiff where
  rnf :: GetSchemaVersionsDiff -> ()
rnf GetSchemaVersionsDiff' {SchemaDiffType
SchemaId
SchemaVersionNumber
schemaDiffType :: SchemaDiffType
secondSchemaVersionNumber :: SchemaVersionNumber
firstSchemaVersionNumber :: SchemaVersionNumber
schemaId :: SchemaId
$sel:schemaDiffType:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaDiffType
$sel:secondSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
$sel:firstSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
$sel:schemaId:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> 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 SchemaVersionNumber
firstSchemaVersionNumber
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf SchemaVersionNumber
secondSchemaVersionNumber
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf SchemaDiffType
schemaDiffType

instance Data.ToHeaders GetSchemaVersionsDiff where
  toHeaders :: GetSchemaVersionsDiff -> 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.GetSchemaVersionsDiff" ::
                          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 GetSchemaVersionsDiff where
  toJSON :: GetSchemaVersionsDiff -> Value
toJSON GetSchemaVersionsDiff' {SchemaDiffType
SchemaId
SchemaVersionNumber
schemaDiffType :: SchemaDiffType
secondSchemaVersionNumber :: SchemaVersionNumber
firstSchemaVersionNumber :: SchemaVersionNumber
schemaId :: SchemaId
$sel:schemaDiffType:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaDiffType
$sel:secondSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
$sel:firstSchemaVersionNumber:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> SchemaVersionNumber
$sel:schemaId:GetSchemaVersionsDiff' :: GetSchemaVersionsDiff -> 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
"FirstSchemaVersionNumber"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SchemaVersionNumber
firstSchemaVersionNumber
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"SecondSchemaVersionNumber"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SchemaVersionNumber
secondSchemaVersionNumber
              ),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"SchemaDiffType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= SchemaDiffType
schemaDiffType)
          ]
      )

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

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

-- | /See:/ 'newGetSchemaVersionsDiffResponse' smart constructor.
data GetSchemaVersionsDiffResponse = GetSchemaVersionsDiffResponse'
  { -- | The difference between schemas as a string in JsonPatch format.
    GetSchemaVersionsDiffResponse -> Maybe Text
diff :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    GetSchemaVersionsDiffResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetSchemaVersionsDiffResponse
-> GetSchemaVersionsDiffResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetSchemaVersionsDiffResponse
-> GetSchemaVersionsDiffResponse -> Bool
$c/= :: GetSchemaVersionsDiffResponse
-> GetSchemaVersionsDiffResponse -> Bool
== :: GetSchemaVersionsDiffResponse
-> GetSchemaVersionsDiffResponse -> Bool
$c== :: GetSchemaVersionsDiffResponse
-> GetSchemaVersionsDiffResponse -> Bool
Prelude.Eq, ReadPrec [GetSchemaVersionsDiffResponse]
ReadPrec GetSchemaVersionsDiffResponse
Int -> ReadS GetSchemaVersionsDiffResponse
ReadS [GetSchemaVersionsDiffResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetSchemaVersionsDiffResponse]
$creadListPrec :: ReadPrec [GetSchemaVersionsDiffResponse]
readPrec :: ReadPrec GetSchemaVersionsDiffResponse
$creadPrec :: ReadPrec GetSchemaVersionsDiffResponse
readList :: ReadS [GetSchemaVersionsDiffResponse]
$creadList :: ReadS [GetSchemaVersionsDiffResponse]
readsPrec :: Int -> ReadS GetSchemaVersionsDiffResponse
$creadsPrec :: Int -> ReadS GetSchemaVersionsDiffResponse
Prelude.Read, Int -> GetSchemaVersionsDiffResponse -> ShowS
[GetSchemaVersionsDiffResponse] -> ShowS
GetSchemaVersionsDiffResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetSchemaVersionsDiffResponse] -> ShowS
$cshowList :: [GetSchemaVersionsDiffResponse] -> ShowS
show :: GetSchemaVersionsDiffResponse -> String
$cshow :: GetSchemaVersionsDiffResponse -> String
showsPrec :: Int -> GetSchemaVersionsDiffResponse -> ShowS
$cshowsPrec :: Int -> GetSchemaVersionsDiffResponse -> ShowS
Prelude.Show, forall x.
Rep GetSchemaVersionsDiffResponse x
-> GetSchemaVersionsDiffResponse
forall x.
GetSchemaVersionsDiffResponse
-> Rep GetSchemaVersionsDiffResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetSchemaVersionsDiffResponse x
-> GetSchemaVersionsDiffResponse
$cfrom :: forall x.
GetSchemaVersionsDiffResponse
-> Rep GetSchemaVersionsDiffResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetSchemaVersionsDiffResponse' 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:
--
-- 'diff', 'getSchemaVersionsDiffResponse_diff' - The difference between schemas as a string in JsonPatch format.
--
-- 'httpStatus', 'getSchemaVersionsDiffResponse_httpStatus' - The response's http status code.
newGetSchemaVersionsDiffResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetSchemaVersionsDiffResponse
newGetSchemaVersionsDiffResponse :: Int -> GetSchemaVersionsDiffResponse
newGetSchemaVersionsDiffResponse Int
pHttpStatus_ =
  GetSchemaVersionsDiffResponse'
    { $sel:diff:GetSchemaVersionsDiffResponse' :: Maybe Text
diff =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetSchemaVersionsDiffResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The difference between schemas as a string in JsonPatch format.
getSchemaVersionsDiffResponse_diff :: Lens.Lens' GetSchemaVersionsDiffResponse (Prelude.Maybe Prelude.Text)
getSchemaVersionsDiffResponse_diff :: Lens' GetSchemaVersionsDiffResponse (Maybe Text)
getSchemaVersionsDiffResponse_diff = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSchemaVersionsDiffResponse' {Maybe Text
diff :: Maybe Text
$sel:diff:GetSchemaVersionsDiffResponse' :: GetSchemaVersionsDiffResponse -> Maybe Text
diff} -> Maybe Text
diff) (\s :: GetSchemaVersionsDiffResponse
s@GetSchemaVersionsDiffResponse' {} Maybe Text
a -> GetSchemaVersionsDiffResponse
s {$sel:diff:GetSchemaVersionsDiffResponse' :: Maybe Text
diff = Maybe Text
a} :: GetSchemaVersionsDiffResponse)

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

instance Prelude.NFData GetSchemaVersionsDiffResponse where
  rnf :: GetSchemaVersionsDiffResponse -> ()
rnf GetSchemaVersionsDiffResponse' {Int
Maybe Text
httpStatus :: Int
diff :: Maybe Text
$sel:httpStatus:GetSchemaVersionsDiffResponse' :: GetSchemaVersionsDiffResponse -> Int
$sel:diff:GetSchemaVersionsDiffResponse' :: GetSchemaVersionsDiffResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
diff
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus