{-# 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.CloudDirectory.PublishSchema
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Publishes a development schema with a major version and a recommended
-- minor version.
module Amazonka.CloudDirectory.PublishSchema
  ( -- * Creating a Request
    PublishSchema (..),
    newPublishSchema,

    -- * Request Lenses
    publishSchema_minorVersion,
    publishSchema_name,
    publishSchema_developmentSchemaArn,
    publishSchema_version,

    -- * Destructuring the Response
    PublishSchemaResponse (..),
    newPublishSchemaResponse,

    -- * Response Lenses
    publishSchemaResponse_publishedSchemaArn,
    publishSchemaResponse_httpStatus,
  )
where

import Amazonka.CloudDirectory.Types
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

-- | /See:/ 'newPublishSchema' smart constructor.
data PublishSchema = PublishSchema'
  { -- | The minor version under which the schema will be published. This
    -- parameter is recommended. Schemas have both a major and minor version
    -- associated with them.
    PublishSchema -> Maybe Text
minorVersion :: Prelude.Maybe Prelude.Text,
    -- | The new name under which the schema will be published. If this is not
    -- provided, the development schema is considered.
    PublishSchema -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) that is associated with the development
    -- schema. For more information, see arns.
    PublishSchema -> Text
developmentSchemaArn :: Prelude.Text,
    -- | The major version under which the schema will be published. Schemas have
    -- both a major and minor version associated with them.
    PublishSchema -> Text
version :: Prelude.Text
  }
  deriving (PublishSchema -> PublishSchema -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublishSchema -> PublishSchema -> Bool
$c/= :: PublishSchema -> PublishSchema -> Bool
== :: PublishSchema -> PublishSchema -> Bool
$c== :: PublishSchema -> PublishSchema -> Bool
Prelude.Eq, ReadPrec [PublishSchema]
ReadPrec PublishSchema
Int -> ReadS PublishSchema
ReadS [PublishSchema]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PublishSchema]
$creadListPrec :: ReadPrec [PublishSchema]
readPrec :: ReadPrec PublishSchema
$creadPrec :: ReadPrec PublishSchema
readList :: ReadS [PublishSchema]
$creadList :: ReadS [PublishSchema]
readsPrec :: Int -> ReadS PublishSchema
$creadsPrec :: Int -> ReadS PublishSchema
Prelude.Read, Int -> PublishSchema -> ShowS
[PublishSchema] -> ShowS
PublishSchema -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublishSchema] -> ShowS
$cshowList :: [PublishSchema] -> ShowS
show :: PublishSchema -> String
$cshow :: PublishSchema -> String
showsPrec :: Int -> PublishSchema -> ShowS
$cshowsPrec :: Int -> PublishSchema -> ShowS
Prelude.Show, forall x. Rep PublishSchema x -> PublishSchema
forall x. PublishSchema -> Rep PublishSchema x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PublishSchema x -> PublishSchema
$cfrom :: forall x. PublishSchema -> Rep PublishSchema x
Prelude.Generic)

-- |
-- Create a value of 'PublishSchema' 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:
--
-- 'minorVersion', 'publishSchema_minorVersion' - The minor version under which the schema will be published. This
-- parameter is recommended. Schemas have both a major and minor version
-- associated with them.
--
-- 'name', 'publishSchema_name' - The new name under which the schema will be published. If this is not
-- provided, the development schema is considered.
--
-- 'developmentSchemaArn', 'publishSchema_developmentSchemaArn' - The Amazon Resource Name (ARN) that is associated with the development
-- schema. For more information, see arns.
--
-- 'version', 'publishSchema_version' - The major version under which the schema will be published. Schemas have
-- both a major and minor version associated with them.
newPublishSchema ::
  -- | 'developmentSchemaArn'
  Prelude.Text ->
  -- | 'version'
  Prelude.Text ->
  PublishSchema
newPublishSchema :: Text -> Text -> PublishSchema
newPublishSchema Text
pDevelopmentSchemaArn_ Text
pVersion_ =
  PublishSchema'
    { $sel:minorVersion:PublishSchema' :: Maybe Text
minorVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:name:PublishSchema' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:developmentSchemaArn:PublishSchema' :: Text
developmentSchemaArn = Text
pDevelopmentSchemaArn_,
      $sel:version:PublishSchema' :: Text
version = Text
pVersion_
    }

-- | The minor version under which the schema will be published. This
-- parameter is recommended. Schemas have both a major and minor version
-- associated with them.
publishSchema_minorVersion :: Lens.Lens' PublishSchema (Prelude.Maybe Prelude.Text)
publishSchema_minorVersion :: Lens' PublishSchema (Maybe Text)
publishSchema_minorVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishSchema' {Maybe Text
minorVersion :: Maybe Text
$sel:minorVersion:PublishSchema' :: PublishSchema -> Maybe Text
minorVersion} -> Maybe Text
minorVersion) (\s :: PublishSchema
s@PublishSchema' {} Maybe Text
a -> PublishSchema
s {$sel:minorVersion:PublishSchema' :: Maybe Text
minorVersion = Maybe Text
a} :: PublishSchema)

-- | The new name under which the schema will be published. If this is not
-- provided, the development schema is considered.
publishSchema_name :: Lens.Lens' PublishSchema (Prelude.Maybe Prelude.Text)
publishSchema_name :: Lens' PublishSchema (Maybe Text)
publishSchema_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishSchema' {Maybe Text
name :: Maybe Text
$sel:name:PublishSchema' :: PublishSchema -> Maybe Text
name} -> Maybe Text
name) (\s :: PublishSchema
s@PublishSchema' {} Maybe Text
a -> PublishSchema
s {$sel:name:PublishSchema' :: Maybe Text
name = Maybe Text
a} :: PublishSchema)

-- | The Amazon Resource Name (ARN) that is associated with the development
-- schema. For more information, see arns.
publishSchema_developmentSchemaArn :: Lens.Lens' PublishSchema Prelude.Text
publishSchema_developmentSchemaArn :: Lens' PublishSchema Text
publishSchema_developmentSchemaArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishSchema' {Text
developmentSchemaArn :: Text
$sel:developmentSchemaArn:PublishSchema' :: PublishSchema -> Text
developmentSchemaArn} -> Text
developmentSchemaArn) (\s :: PublishSchema
s@PublishSchema' {} Text
a -> PublishSchema
s {$sel:developmentSchemaArn:PublishSchema' :: Text
developmentSchemaArn = Text
a} :: PublishSchema)

-- | The major version under which the schema will be published. Schemas have
-- both a major and minor version associated with them.
publishSchema_version :: Lens.Lens' PublishSchema Prelude.Text
publishSchema_version :: Lens' PublishSchema Text
publishSchema_version = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishSchema' {Text
version :: Text
$sel:version:PublishSchema' :: PublishSchema -> Text
version} -> Text
version) (\s :: PublishSchema
s@PublishSchema' {} Text
a -> PublishSchema
s {$sel:version:PublishSchema' :: Text
version = Text
a} :: PublishSchema)

instance Core.AWSRequest PublishSchema where
  type
    AWSResponse PublishSchema =
      PublishSchemaResponse
  request :: (Service -> Service) -> PublishSchema -> Request PublishSchema
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.putJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy PublishSchema
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse PublishSchema)))
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 -> PublishSchemaResponse
PublishSchemaResponse'
            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
"PublishedSchemaArn")
            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 PublishSchema where
  hashWithSalt :: Int -> PublishSchema -> Int
hashWithSalt Int
_salt PublishSchema' {Maybe Text
Text
version :: Text
developmentSchemaArn :: Text
name :: Maybe Text
minorVersion :: Maybe Text
$sel:version:PublishSchema' :: PublishSchema -> Text
$sel:developmentSchemaArn:PublishSchema' :: PublishSchema -> Text
$sel:name:PublishSchema' :: PublishSchema -> Maybe Text
$sel:minorVersion:PublishSchema' :: PublishSchema -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
minorVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
developmentSchemaArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
version

instance Prelude.NFData PublishSchema where
  rnf :: PublishSchema -> ()
rnf PublishSchema' {Maybe Text
Text
version :: Text
developmentSchemaArn :: Text
name :: Maybe Text
minorVersion :: Maybe Text
$sel:version:PublishSchema' :: PublishSchema -> Text
$sel:developmentSchemaArn:PublishSchema' :: PublishSchema -> Text
$sel:name:PublishSchema' :: PublishSchema -> Maybe Text
$sel:minorVersion:PublishSchema' :: PublishSchema -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
minorVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
developmentSchemaArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
version

instance Data.ToHeaders PublishSchema where
  toHeaders :: PublishSchema -> ResponseHeaders
toHeaders PublishSchema' {Maybe Text
Text
version :: Text
developmentSchemaArn :: Text
name :: Maybe Text
minorVersion :: Maybe Text
$sel:version:PublishSchema' :: PublishSchema -> Text
$sel:developmentSchemaArn:PublishSchema' :: PublishSchema -> Text
$sel:name:PublishSchema' :: PublishSchema -> Maybe Text
$sel:minorVersion:PublishSchema' :: PublishSchema -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [HeaderName
"x-amz-data-partition" forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Text
developmentSchemaArn]

instance Data.ToJSON PublishSchema where
  toJSON :: PublishSchema -> Value
toJSON PublishSchema' {Maybe Text
Text
version :: Text
developmentSchemaArn :: Text
name :: Maybe Text
minorVersion :: Maybe Text
$sel:version:PublishSchema' :: PublishSchema -> Text
$sel:developmentSchemaArn:PublishSchema' :: PublishSchema -> Text
$sel:name:PublishSchema' :: PublishSchema -> Maybe Text
$sel:minorVersion:PublishSchema' :: PublishSchema -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"MinorVersion" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
minorVersion,
            (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
name,
            forall a. a -> Maybe a
Prelude.Just (Key
"Version" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
version)
          ]
      )

instance Data.ToPath PublishSchema where
  toPath :: PublishSchema -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const
      ByteString
"/amazonclouddirectory/2017-01-11/schema/publish"

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

-- | /See:/ 'newPublishSchemaResponse' smart constructor.
data PublishSchemaResponse = PublishSchemaResponse'
  { -- | The ARN that is associated with the published schema. For more
    -- information, see arns.
    PublishSchemaResponse -> Maybe Text
publishedSchemaArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    PublishSchemaResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (PublishSchemaResponse -> PublishSchemaResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublishSchemaResponse -> PublishSchemaResponse -> Bool
$c/= :: PublishSchemaResponse -> PublishSchemaResponse -> Bool
== :: PublishSchemaResponse -> PublishSchemaResponse -> Bool
$c== :: PublishSchemaResponse -> PublishSchemaResponse -> Bool
Prelude.Eq, ReadPrec [PublishSchemaResponse]
ReadPrec PublishSchemaResponse
Int -> ReadS PublishSchemaResponse
ReadS [PublishSchemaResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PublishSchemaResponse]
$creadListPrec :: ReadPrec [PublishSchemaResponse]
readPrec :: ReadPrec PublishSchemaResponse
$creadPrec :: ReadPrec PublishSchemaResponse
readList :: ReadS [PublishSchemaResponse]
$creadList :: ReadS [PublishSchemaResponse]
readsPrec :: Int -> ReadS PublishSchemaResponse
$creadsPrec :: Int -> ReadS PublishSchemaResponse
Prelude.Read, Int -> PublishSchemaResponse -> ShowS
[PublishSchemaResponse] -> ShowS
PublishSchemaResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublishSchemaResponse] -> ShowS
$cshowList :: [PublishSchemaResponse] -> ShowS
show :: PublishSchemaResponse -> String
$cshow :: PublishSchemaResponse -> String
showsPrec :: Int -> PublishSchemaResponse -> ShowS
$cshowsPrec :: Int -> PublishSchemaResponse -> ShowS
Prelude.Show, forall x. Rep PublishSchemaResponse x -> PublishSchemaResponse
forall x. PublishSchemaResponse -> Rep PublishSchemaResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PublishSchemaResponse x -> PublishSchemaResponse
$cfrom :: forall x. PublishSchemaResponse -> Rep PublishSchemaResponse x
Prelude.Generic)

-- |
-- Create a value of 'PublishSchemaResponse' 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:
--
-- 'publishedSchemaArn', 'publishSchemaResponse_publishedSchemaArn' - The ARN that is associated with the published schema. For more
-- information, see arns.
--
-- 'httpStatus', 'publishSchemaResponse_httpStatus' - The response's http status code.
newPublishSchemaResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PublishSchemaResponse
newPublishSchemaResponse :: Int -> PublishSchemaResponse
newPublishSchemaResponse Int
pHttpStatus_ =
  PublishSchemaResponse'
    { $sel:publishedSchemaArn:PublishSchemaResponse' :: Maybe Text
publishedSchemaArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:PublishSchemaResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN that is associated with the published schema. For more
-- information, see arns.
publishSchemaResponse_publishedSchemaArn :: Lens.Lens' PublishSchemaResponse (Prelude.Maybe Prelude.Text)
publishSchemaResponse_publishedSchemaArn :: Lens' PublishSchemaResponse (Maybe Text)
publishSchemaResponse_publishedSchemaArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishSchemaResponse' {Maybe Text
publishedSchemaArn :: Maybe Text
$sel:publishedSchemaArn:PublishSchemaResponse' :: PublishSchemaResponse -> Maybe Text
publishedSchemaArn} -> Maybe Text
publishedSchemaArn) (\s :: PublishSchemaResponse
s@PublishSchemaResponse' {} Maybe Text
a -> PublishSchemaResponse
s {$sel:publishedSchemaArn:PublishSchemaResponse' :: Maybe Text
publishedSchemaArn = Maybe Text
a} :: PublishSchemaResponse)

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

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