{-# 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.ConnectCases.CreateTemplate
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a template in the Cases domain. This template is used to define
-- the case object model (that is, to define what data can be captured on
-- cases) in a Cases domain. A template must have a unique name within a
-- domain, and it must reference existing field IDs and layout IDs.
-- Additionally, multiple fields with same IDs are not allowed within the
-- same Template. A template can be either Active or Inactive, as indicated
-- by its status. Inactive templates cannot be used to create cases.
module Amazonka.ConnectCases.CreateTemplate
  ( -- * Creating a Request
    CreateTemplate (..),
    newCreateTemplate,

    -- * Request Lenses
    createTemplate_description,
    createTemplate_layoutConfiguration,
    createTemplate_requiredFields,
    createTemplate_status,
    createTemplate_domainId,
    createTemplate_name,

    -- * Destructuring the Response
    CreateTemplateResponse (..),
    newCreateTemplateResponse,

    -- * Response Lenses
    createTemplateResponse_httpStatus,
    createTemplateResponse_templateArn,
    createTemplateResponse_templateId,
  )
where

import Amazonka.ConnectCases.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:/ 'newCreateTemplate' smart constructor.
data CreateTemplate = CreateTemplate'
  { -- | A brief description of the template.
    CreateTemplate -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Configuration of layouts associated to the template.
    CreateTemplate -> Maybe LayoutConfiguration
layoutConfiguration :: Prelude.Maybe LayoutConfiguration,
    -- | A list of fields that must contain a value for a case to be successfully
    -- created with this template.
    CreateTemplate -> Maybe [RequiredField]
requiredFields :: Prelude.Maybe [RequiredField],
    -- | The status of the template.
    CreateTemplate -> Maybe TemplateStatus
status :: Prelude.Maybe TemplateStatus,
    -- | The unique identifier of the Cases domain.
    CreateTemplate -> Text
domainId :: Prelude.Text,
    -- | A name for the template. It must be unique per domain.
    CreateTemplate -> Text
name :: Prelude.Text
  }
  deriving (CreateTemplate -> CreateTemplate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTemplate -> CreateTemplate -> Bool
$c/= :: CreateTemplate -> CreateTemplate -> Bool
== :: CreateTemplate -> CreateTemplate -> Bool
$c== :: CreateTemplate -> CreateTemplate -> Bool
Prelude.Eq, ReadPrec [CreateTemplate]
ReadPrec CreateTemplate
Int -> ReadS CreateTemplate
ReadS [CreateTemplate]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTemplate]
$creadListPrec :: ReadPrec [CreateTemplate]
readPrec :: ReadPrec CreateTemplate
$creadPrec :: ReadPrec CreateTemplate
readList :: ReadS [CreateTemplate]
$creadList :: ReadS [CreateTemplate]
readsPrec :: Int -> ReadS CreateTemplate
$creadsPrec :: Int -> ReadS CreateTemplate
Prelude.Read, Int -> CreateTemplate -> ShowS
[CreateTemplate] -> ShowS
CreateTemplate -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTemplate] -> ShowS
$cshowList :: [CreateTemplate] -> ShowS
show :: CreateTemplate -> String
$cshow :: CreateTemplate -> String
showsPrec :: Int -> CreateTemplate -> ShowS
$cshowsPrec :: Int -> CreateTemplate -> ShowS
Prelude.Show, forall x. Rep CreateTemplate x -> CreateTemplate
forall x. CreateTemplate -> Rep CreateTemplate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateTemplate x -> CreateTemplate
$cfrom :: forall x. CreateTemplate -> Rep CreateTemplate x
Prelude.Generic)

-- |
-- Create a value of 'CreateTemplate' 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:
--
-- 'description', 'createTemplate_description' - A brief description of the template.
--
-- 'layoutConfiguration', 'createTemplate_layoutConfiguration' - Configuration of layouts associated to the template.
--
-- 'requiredFields', 'createTemplate_requiredFields' - A list of fields that must contain a value for a case to be successfully
-- created with this template.
--
-- 'status', 'createTemplate_status' - The status of the template.
--
-- 'domainId', 'createTemplate_domainId' - The unique identifier of the Cases domain.
--
-- 'name', 'createTemplate_name' - A name for the template. It must be unique per domain.
newCreateTemplate ::
  -- | 'domainId'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  CreateTemplate
newCreateTemplate :: Text -> Text -> CreateTemplate
newCreateTemplate Text
pDomainId_ Text
pName_ =
  CreateTemplate'
    { $sel:description:CreateTemplate' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:layoutConfiguration:CreateTemplate' :: Maybe LayoutConfiguration
layoutConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:requiredFields:CreateTemplate' :: Maybe [RequiredField]
requiredFields = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateTemplate' :: Maybe TemplateStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:domainId:CreateTemplate' :: Text
domainId = Text
pDomainId_,
      $sel:name:CreateTemplate' :: Text
name = Text
pName_
    }

-- | A brief description of the template.
createTemplate_description :: Lens.Lens' CreateTemplate (Prelude.Maybe Prelude.Text)
createTemplate_description :: Lens' CreateTemplate (Maybe Text)
createTemplate_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe Text
description :: Maybe Text
$sel:description:CreateTemplate' :: CreateTemplate -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe Text
a -> CreateTemplate
s {$sel:description:CreateTemplate' :: Maybe Text
description = Maybe Text
a} :: CreateTemplate)

-- | Configuration of layouts associated to the template.
createTemplate_layoutConfiguration :: Lens.Lens' CreateTemplate (Prelude.Maybe LayoutConfiguration)
createTemplate_layoutConfiguration :: Lens' CreateTemplate (Maybe LayoutConfiguration)
createTemplate_layoutConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe LayoutConfiguration
layoutConfiguration :: Maybe LayoutConfiguration
$sel:layoutConfiguration:CreateTemplate' :: CreateTemplate -> Maybe LayoutConfiguration
layoutConfiguration} -> Maybe LayoutConfiguration
layoutConfiguration) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe LayoutConfiguration
a -> CreateTemplate
s {$sel:layoutConfiguration:CreateTemplate' :: Maybe LayoutConfiguration
layoutConfiguration = Maybe LayoutConfiguration
a} :: CreateTemplate)

-- | A list of fields that must contain a value for a case to be successfully
-- created with this template.
createTemplate_requiredFields :: Lens.Lens' CreateTemplate (Prelude.Maybe [RequiredField])
createTemplate_requiredFields :: Lens' CreateTemplate (Maybe [RequiredField])
createTemplate_requiredFields = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe [RequiredField]
requiredFields :: Maybe [RequiredField]
$sel:requiredFields:CreateTemplate' :: CreateTemplate -> Maybe [RequiredField]
requiredFields} -> Maybe [RequiredField]
requiredFields) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe [RequiredField]
a -> CreateTemplate
s {$sel:requiredFields:CreateTemplate' :: Maybe [RequiredField]
requiredFields = Maybe [RequiredField]
a} :: CreateTemplate) 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 status of the template.
createTemplate_status :: Lens.Lens' CreateTemplate (Prelude.Maybe TemplateStatus)
createTemplate_status :: Lens' CreateTemplate (Maybe TemplateStatus)
createTemplate_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe TemplateStatus
status :: Maybe TemplateStatus
$sel:status:CreateTemplate' :: CreateTemplate -> Maybe TemplateStatus
status} -> Maybe TemplateStatus
status) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe TemplateStatus
a -> CreateTemplate
s {$sel:status:CreateTemplate' :: Maybe TemplateStatus
status = Maybe TemplateStatus
a} :: CreateTemplate)

-- | The unique identifier of the Cases domain.
createTemplate_domainId :: Lens.Lens' CreateTemplate Prelude.Text
createTemplate_domainId :: Lens' CreateTemplate Text
createTemplate_domainId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Text
domainId :: Text
$sel:domainId:CreateTemplate' :: CreateTemplate -> Text
domainId} -> Text
domainId) (\s :: CreateTemplate
s@CreateTemplate' {} Text
a -> CreateTemplate
s {$sel:domainId:CreateTemplate' :: Text
domainId = Text
a} :: CreateTemplate)

-- | A name for the template. It must be unique per domain.
createTemplate_name :: Lens.Lens' CreateTemplate Prelude.Text
createTemplate_name :: Lens' CreateTemplate Text
createTemplate_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Text
name :: Text
$sel:name:CreateTemplate' :: CreateTemplate -> Text
name} -> Text
name) (\s :: CreateTemplate
s@CreateTemplate' {} Text
a -> CreateTemplate
s {$sel:name:CreateTemplate' :: Text
name = Text
a} :: CreateTemplate)

instance Core.AWSRequest CreateTemplate where
  type
    AWSResponse CreateTemplate =
      CreateTemplateResponse
  request :: (Service -> Service) -> CreateTemplate -> Request CreateTemplate
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 CreateTemplate
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateTemplate)))
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 ->
          Int -> Text -> Text -> CreateTemplateResponse
CreateTemplateResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"templateArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"templateId")
      )

instance Prelude.Hashable CreateTemplate where
  hashWithSalt :: Int -> CreateTemplate -> Int
hashWithSalt Int
_salt CreateTemplate' {Maybe [RequiredField]
Maybe Text
Maybe LayoutConfiguration
Maybe TemplateStatus
Text
name :: Text
domainId :: Text
status :: Maybe TemplateStatus
requiredFields :: Maybe [RequiredField]
layoutConfiguration :: Maybe LayoutConfiguration
description :: Maybe Text
$sel:name:CreateTemplate' :: CreateTemplate -> Text
$sel:domainId:CreateTemplate' :: CreateTemplate -> Text
$sel:status:CreateTemplate' :: CreateTemplate -> Maybe TemplateStatus
$sel:requiredFields:CreateTemplate' :: CreateTemplate -> Maybe [RequiredField]
$sel:layoutConfiguration:CreateTemplate' :: CreateTemplate -> Maybe LayoutConfiguration
$sel:description:CreateTemplate' :: CreateTemplate -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LayoutConfiguration
layoutConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [RequiredField]
requiredFields
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TemplateStatus
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateTemplate where
  rnf :: CreateTemplate -> ()
rnf CreateTemplate' {Maybe [RequiredField]
Maybe Text
Maybe LayoutConfiguration
Maybe TemplateStatus
Text
name :: Text
domainId :: Text
status :: Maybe TemplateStatus
requiredFields :: Maybe [RequiredField]
layoutConfiguration :: Maybe LayoutConfiguration
description :: Maybe Text
$sel:name:CreateTemplate' :: CreateTemplate -> Text
$sel:domainId:CreateTemplate' :: CreateTemplate -> Text
$sel:status:CreateTemplate' :: CreateTemplate -> Maybe TemplateStatus
$sel:requiredFields:CreateTemplate' :: CreateTemplate -> Maybe [RequiredField]
$sel:layoutConfiguration:CreateTemplate' :: CreateTemplate -> Maybe LayoutConfiguration
$sel:description:CreateTemplate' :: CreateTemplate -> Maybe Text
..} =
    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 LayoutConfiguration
layoutConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [RequiredField]
requiredFields
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TemplateStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name

instance Data.ToHeaders CreateTemplate where
  toHeaders :: CreateTemplate -> 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.ToJSON CreateTemplate where
  toJSON :: CreateTemplate -> Value
toJSON CreateTemplate' {Maybe [RequiredField]
Maybe Text
Maybe LayoutConfiguration
Maybe TemplateStatus
Text
name :: Text
domainId :: Text
status :: Maybe TemplateStatus
requiredFields :: Maybe [RequiredField]
layoutConfiguration :: Maybe LayoutConfiguration
description :: Maybe Text
$sel:name:CreateTemplate' :: CreateTemplate -> Text
$sel:domainId:CreateTemplate' :: CreateTemplate -> Text
$sel:status:CreateTemplate' :: CreateTemplate -> Maybe TemplateStatus
$sel:requiredFields:CreateTemplate' :: CreateTemplate -> Maybe [RequiredField]
$sel:layoutConfiguration:CreateTemplate' :: CreateTemplate -> Maybe LayoutConfiguration
$sel:description:CreateTemplate' :: CreateTemplate -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" 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
description,
            (Key
"layoutConfiguration" 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 LayoutConfiguration
layoutConfiguration,
            (Key
"requiredFields" 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 [RequiredField]
requiredFields,
            (Key
"status" 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 TemplateStatus
status,
            forall a. a -> Maybe a
Prelude.Just (Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

instance Data.ToPath CreateTemplate where
  toPath :: CreateTemplate -> ByteString
toPath CreateTemplate' {Maybe [RequiredField]
Maybe Text
Maybe LayoutConfiguration
Maybe TemplateStatus
Text
name :: Text
domainId :: Text
status :: Maybe TemplateStatus
requiredFields :: Maybe [RequiredField]
layoutConfiguration :: Maybe LayoutConfiguration
description :: Maybe Text
$sel:name:CreateTemplate' :: CreateTemplate -> Text
$sel:domainId:CreateTemplate' :: CreateTemplate -> Text
$sel:status:CreateTemplate' :: CreateTemplate -> Maybe TemplateStatus
$sel:requiredFields:CreateTemplate' :: CreateTemplate -> Maybe [RequiredField]
$sel:layoutConfiguration:CreateTemplate' :: CreateTemplate -> Maybe LayoutConfiguration
$sel:description:CreateTemplate' :: CreateTemplate -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/domains/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
domainId, ByteString
"/templates"]

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

-- | /See:/ 'newCreateTemplateResponse' smart constructor.
data CreateTemplateResponse = CreateTemplateResponse'
  { -- | The response's http status code.
    CreateTemplateResponse -> Int
httpStatus :: Prelude.Int,
    -- | The Amazon Resource Name (ARN) of the newly created template.
    CreateTemplateResponse -> Text
templateArn :: Prelude.Text,
    -- | A unique identifier of a template.
    CreateTemplateResponse -> Text
templateId :: Prelude.Text
  }
  deriving (CreateTemplateResponse -> CreateTemplateResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateTemplateResponse -> CreateTemplateResponse -> Bool
$c/= :: CreateTemplateResponse -> CreateTemplateResponse -> Bool
== :: CreateTemplateResponse -> CreateTemplateResponse -> Bool
$c== :: CreateTemplateResponse -> CreateTemplateResponse -> Bool
Prelude.Eq, ReadPrec [CreateTemplateResponse]
ReadPrec CreateTemplateResponse
Int -> ReadS CreateTemplateResponse
ReadS [CreateTemplateResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateTemplateResponse]
$creadListPrec :: ReadPrec [CreateTemplateResponse]
readPrec :: ReadPrec CreateTemplateResponse
$creadPrec :: ReadPrec CreateTemplateResponse
readList :: ReadS [CreateTemplateResponse]
$creadList :: ReadS [CreateTemplateResponse]
readsPrec :: Int -> ReadS CreateTemplateResponse
$creadsPrec :: Int -> ReadS CreateTemplateResponse
Prelude.Read, Int -> CreateTemplateResponse -> ShowS
[CreateTemplateResponse] -> ShowS
CreateTemplateResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateTemplateResponse] -> ShowS
$cshowList :: [CreateTemplateResponse] -> ShowS
show :: CreateTemplateResponse -> String
$cshow :: CreateTemplateResponse -> String
showsPrec :: Int -> CreateTemplateResponse -> ShowS
$cshowsPrec :: Int -> CreateTemplateResponse -> ShowS
Prelude.Show, forall x. Rep CreateTemplateResponse x -> CreateTemplateResponse
forall x. CreateTemplateResponse -> Rep CreateTemplateResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateTemplateResponse x -> CreateTemplateResponse
$cfrom :: forall x. CreateTemplateResponse -> Rep CreateTemplateResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateTemplateResponse' 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:
--
-- 'httpStatus', 'createTemplateResponse_httpStatus' - The response's http status code.
--
-- 'templateArn', 'createTemplateResponse_templateArn' - The Amazon Resource Name (ARN) of the newly created template.
--
-- 'templateId', 'createTemplateResponse_templateId' - A unique identifier of a template.
newCreateTemplateResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'templateArn'
  Prelude.Text ->
  -- | 'templateId'
  Prelude.Text ->
  CreateTemplateResponse
newCreateTemplateResponse :: Int -> Text -> Text -> CreateTemplateResponse
newCreateTemplateResponse
  Int
pHttpStatus_
  Text
pTemplateArn_
  Text
pTemplateId_ =
    CreateTemplateResponse'
      { $sel:httpStatus:CreateTemplateResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:templateArn:CreateTemplateResponse' :: Text
templateArn = Text
pTemplateArn_,
        $sel:templateId:CreateTemplateResponse' :: Text
templateId = Text
pTemplateId_
      }

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

-- | The Amazon Resource Name (ARN) of the newly created template.
createTemplateResponse_templateArn :: Lens.Lens' CreateTemplateResponse Prelude.Text
createTemplateResponse_templateArn :: Lens' CreateTemplateResponse Text
createTemplateResponse_templateArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Text
templateArn :: Text
$sel:templateArn:CreateTemplateResponse' :: CreateTemplateResponse -> Text
templateArn} -> Text
templateArn) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Text
a -> CreateTemplateResponse
s {$sel:templateArn:CreateTemplateResponse' :: Text
templateArn = Text
a} :: CreateTemplateResponse)

-- | A unique identifier of a template.
createTemplateResponse_templateId :: Lens.Lens' CreateTemplateResponse Prelude.Text
createTemplateResponse_templateId :: Lens' CreateTemplateResponse Text
createTemplateResponse_templateId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Text
templateId :: Text
$sel:templateId:CreateTemplateResponse' :: CreateTemplateResponse -> Text
templateId} -> Text
templateId) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Text
a -> CreateTemplateResponse
s {$sel:templateId:CreateTemplateResponse' :: Text
templateId = Text
a} :: CreateTemplateResponse)

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