{-# 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.QuickSight.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 from an existing Amazon QuickSight analysis or
-- template. You can use the resulting template to create a dashboard.
--
-- A /template/ is an entity in Amazon QuickSight that encapsulates the
-- metadata required to create an analysis and that you can use to create s
-- dashboard. A template adds a layer of abstraction by using placeholders
-- to replace the dataset associated with the analysis. You can use
-- templates to create dashboards by replacing dataset placeholders with
-- datasets that follow the same schema that was used to create the source
-- analysis and template.
module Amazonka.QuickSight.CreateTemplate
  ( -- * Creating a Request
    CreateTemplate (..),
    newCreateTemplate,

    -- * Request Lenses
    createTemplate_definition,
    createTemplate_name,
    createTemplate_permissions,
    createTemplate_sourceEntity,
    createTemplate_tags,
    createTemplate_versionDescription,
    createTemplate_awsAccountId,
    createTemplate_templateId,

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

    -- * Response Lenses
    createTemplateResponse_arn,
    createTemplateResponse_creationStatus,
    createTemplateResponse_requestId,
    createTemplateResponse_templateId,
    createTemplateResponse_versionArn,
    createTemplateResponse_status,
  )
where

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 Amazonka.QuickSight.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateTemplate' smart constructor.
data CreateTemplate = CreateTemplate'
  { -- | The definition of a template.
    --
    -- A definition is the data model of all features in a Dashboard, Template,
    -- or Analysis.
    CreateTemplate -> Maybe TemplateVersionDefinition
definition :: Prelude.Maybe TemplateVersionDefinition,
    -- | A display name for the template.
    CreateTemplate -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | A list of resource permissions to be set on the template.
    CreateTemplate -> Maybe (NonEmpty ResourcePermission)
permissions :: Prelude.Maybe (Prelude.NonEmpty ResourcePermission),
    -- | The entity that you are using as a source when you create the template.
    -- In @SourceEntity@, you specify the type of object you\'re using as
    -- source: @SourceTemplate@ for a template or @SourceAnalysis@ for an
    -- analysis. Both of these require an Amazon Resource Name (ARN). For
    -- @SourceTemplate@, specify the ARN of the source template. For
    -- @SourceAnalysis@, specify the ARN of the source analysis. The
    -- @SourceTemplate@ ARN can contain any Amazon Web Services account and any
    -- Amazon QuickSight-supported Amazon Web Services Region.
    --
    -- Use the @DataSetReferences@ entity within @SourceTemplate@ or
    -- @SourceAnalysis@ to list the replacement datasets for the placeholders
    -- listed in the original. The schema in each dataset must match its
    -- placeholder.
    CreateTemplate -> Maybe TemplateSourceEntity
sourceEntity :: Prelude.Maybe TemplateSourceEntity,
    -- | Contains a map of the key-value pairs for the resource tag or tags
    -- assigned to the resource.
    CreateTemplate -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | A description of the current template version being created. This API
    -- operation creates the first version of the template. Every time
    -- @UpdateTemplate@ is called, a new version is created. Each version of
    -- the template maintains a description of the version in the
    -- @VersionDescription@ field.
    CreateTemplate -> Maybe Text
versionDescription :: Prelude.Maybe Prelude.Text,
    -- | The ID for the Amazon Web Services account that the group is in. You use
    -- the ID for the Amazon Web Services account that contains your Amazon
    -- QuickSight account.
    CreateTemplate -> Text
awsAccountId :: Prelude.Text,
    -- | An ID for the template that you want to create. This template is unique
    -- per Amazon Web Services Region; in each Amazon Web Services account.
    CreateTemplate -> Text
templateId :: 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, 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:
--
-- 'definition', 'createTemplate_definition' - The definition of a template.
--
-- A definition is the data model of all features in a Dashboard, Template,
-- or Analysis.
--
-- 'name', 'createTemplate_name' - A display name for the template.
--
-- 'permissions', 'createTemplate_permissions' - A list of resource permissions to be set on the template.
--
-- 'sourceEntity', 'createTemplate_sourceEntity' - The entity that you are using as a source when you create the template.
-- In @SourceEntity@, you specify the type of object you\'re using as
-- source: @SourceTemplate@ for a template or @SourceAnalysis@ for an
-- analysis. Both of these require an Amazon Resource Name (ARN). For
-- @SourceTemplate@, specify the ARN of the source template. For
-- @SourceAnalysis@, specify the ARN of the source analysis. The
-- @SourceTemplate@ ARN can contain any Amazon Web Services account and any
-- Amazon QuickSight-supported Amazon Web Services Region.
--
-- Use the @DataSetReferences@ entity within @SourceTemplate@ or
-- @SourceAnalysis@ to list the replacement datasets for the placeholders
-- listed in the original. The schema in each dataset must match its
-- placeholder.
--
-- 'tags', 'createTemplate_tags' - Contains a map of the key-value pairs for the resource tag or tags
-- assigned to the resource.
--
-- 'versionDescription', 'createTemplate_versionDescription' - A description of the current template version being created. This API
-- operation creates the first version of the template. Every time
-- @UpdateTemplate@ is called, a new version is created. Each version of
-- the template maintains a description of the version in the
-- @VersionDescription@ field.
--
-- 'awsAccountId', 'createTemplate_awsAccountId' - The ID for the Amazon Web Services account that the group is in. You use
-- the ID for the Amazon Web Services account that contains your Amazon
-- QuickSight account.
--
-- 'templateId', 'createTemplate_templateId' - An ID for the template that you want to create. This template is unique
-- per Amazon Web Services Region; in each Amazon Web Services account.
newCreateTemplate ::
  -- | 'awsAccountId'
  Prelude.Text ->
  -- | 'templateId'
  Prelude.Text ->
  CreateTemplate
newCreateTemplate :: Text -> Text -> CreateTemplate
newCreateTemplate Text
pAwsAccountId_ Text
pTemplateId_ =
  CreateTemplate'
    { $sel:definition:CreateTemplate' :: Maybe TemplateVersionDefinition
definition = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateTemplate' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:permissions:CreateTemplate' :: Maybe (NonEmpty ResourcePermission)
permissions = forall a. Maybe a
Prelude.Nothing,
      $sel:sourceEntity:CreateTemplate' :: Maybe TemplateSourceEntity
sourceEntity = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateTemplate' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:versionDescription:CreateTemplate' :: Maybe Text
versionDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:awsAccountId:CreateTemplate' :: Text
awsAccountId = Text
pAwsAccountId_,
      $sel:templateId:CreateTemplate' :: Text
templateId = Text
pTemplateId_
    }

-- | The definition of a template.
--
-- A definition is the data model of all features in a Dashboard, Template,
-- or Analysis.
createTemplate_definition :: Lens.Lens' CreateTemplate (Prelude.Maybe TemplateVersionDefinition)
createTemplate_definition :: Lens' CreateTemplate (Maybe TemplateVersionDefinition)
createTemplate_definition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe TemplateVersionDefinition
definition :: Maybe TemplateVersionDefinition
$sel:definition:CreateTemplate' :: CreateTemplate -> Maybe TemplateVersionDefinition
definition} -> Maybe TemplateVersionDefinition
definition) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe TemplateVersionDefinition
a -> CreateTemplate
s {$sel:definition:CreateTemplate' :: Maybe TemplateVersionDefinition
definition = Maybe TemplateVersionDefinition
a} :: CreateTemplate)

-- | A display name for the template.
createTemplate_name :: Lens.Lens' CreateTemplate (Prelude.Maybe Prelude.Text)
createTemplate_name :: Lens' CreateTemplate (Maybe Text)
createTemplate_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe Text
name :: Maybe Text
$sel:name:CreateTemplate' :: CreateTemplate -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe Text
a -> CreateTemplate
s {$sel:name:CreateTemplate' :: Maybe Text
name = Maybe Text
a} :: CreateTemplate)

-- | A list of resource permissions to be set on the template.
createTemplate_permissions :: Lens.Lens' CreateTemplate (Prelude.Maybe (Prelude.NonEmpty ResourcePermission))
createTemplate_permissions :: Lens' CreateTemplate (Maybe (NonEmpty ResourcePermission))
createTemplate_permissions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe (NonEmpty ResourcePermission)
permissions :: Maybe (NonEmpty ResourcePermission)
$sel:permissions:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty ResourcePermission)
permissions} -> Maybe (NonEmpty ResourcePermission)
permissions) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe (NonEmpty ResourcePermission)
a -> CreateTemplate
s {$sel:permissions:CreateTemplate' :: Maybe (NonEmpty ResourcePermission)
permissions = Maybe (NonEmpty ResourcePermission)
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 entity that you are using as a source when you create the template.
-- In @SourceEntity@, you specify the type of object you\'re using as
-- source: @SourceTemplate@ for a template or @SourceAnalysis@ for an
-- analysis. Both of these require an Amazon Resource Name (ARN). For
-- @SourceTemplate@, specify the ARN of the source template. For
-- @SourceAnalysis@, specify the ARN of the source analysis. The
-- @SourceTemplate@ ARN can contain any Amazon Web Services account and any
-- Amazon QuickSight-supported Amazon Web Services Region.
--
-- Use the @DataSetReferences@ entity within @SourceTemplate@ or
-- @SourceAnalysis@ to list the replacement datasets for the placeholders
-- listed in the original. The schema in each dataset must match its
-- placeholder.
createTemplate_sourceEntity :: Lens.Lens' CreateTemplate (Prelude.Maybe TemplateSourceEntity)
createTemplate_sourceEntity :: Lens' CreateTemplate (Maybe TemplateSourceEntity)
createTemplate_sourceEntity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe TemplateSourceEntity
sourceEntity :: Maybe TemplateSourceEntity
$sel:sourceEntity:CreateTemplate' :: CreateTemplate -> Maybe TemplateSourceEntity
sourceEntity} -> Maybe TemplateSourceEntity
sourceEntity) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe TemplateSourceEntity
a -> CreateTemplate
s {$sel:sourceEntity:CreateTemplate' :: Maybe TemplateSourceEntity
sourceEntity = Maybe TemplateSourceEntity
a} :: CreateTemplate)

-- | Contains a map of the key-value pairs for the resource tag or tags
-- assigned to the resource.
createTemplate_tags :: Lens.Lens' CreateTemplate (Prelude.Maybe (Prelude.NonEmpty Tag))
createTemplate_tags :: Lens' CreateTemplate (Maybe (NonEmpty Tag))
createTemplate_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe (NonEmpty Tag)
a -> CreateTemplate
s {$sel:tags:CreateTemplate' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
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

-- | A description of the current template version being created. This API
-- operation creates the first version of the template. Every time
-- @UpdateTemplate@ is called, a new version is created. Each version of
-- the template maintains a description of the version in the
-- @VersionDescription@ field.
createTemplate_versionDescription :: Lens.Lens' CreateTemplate (Prelude.Maybe Prelude.Text)
createTemplate_versionDescription :: Lens' CreateTemplate (Maybe Text)
createTemplate_versionDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Maybe Text
versionDescription :: Maybe Text
$sel:versionDescription:CreateTemplate' :: CreateTemplate -> Maybe Text
versionDescription} -> Maybe Text
versionDescription) (\s :: CreateTemplate
s@CreateTemplate' {} Maybe Text
a -> CreateTemplate
s {$sel:versionDescription:CreateTemplate' :: Maybe Text
versionDescription = Maybe Text
a} :: CreateTemplate)

-- | The ID for the Amazon Web Services account that the group is in. You use
-- the ID for the Amazon Web Services account that contains your Amazon
-- QuickSight account.
createTemplate_awsAccountId :: Lens.Lens' CreateTemplate Prelude.Text
createTemplate_awsAccountId :: Lens' CreateTemplate Text
createTemplate_awsAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Text
awsAccountId :: Text
$sel:awsAccountId:CreateTemplate' :: CreateTemplate -> Text
awsAccountId} -> Text
awsAccountId) (\s :: CreateTemplate
s@CreateTemplate' {} Text
a -> CreateTemplate
s {$sel:awsAccountId:CreateTemplate' :: Text
awsAccountId = Text
a} :: CreateTemplate)

-- | An ID for the template that you want to create. This template is unique
-- per Amazon Web Services Region; in each Amazon Web Services account.
createTemplate_templateId :: Lens.Lens' CreateTemplate Prelude.Text
createTemplate_templateId :: Lens' CreateTemplate Text
createTemplate_templateId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplate' {Text
templateId :: Text
$sel:templateId:CreateTemplate' :: CreateTemplate -> Text
templateId} -> Text
templateId) (\s :: CreateTemplate
s@CreateTemplate' {} Text
a -> CreateTemplate
s {$sel:templateId:CreateTemplate' :: Text
templateId = 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 ->
          Maybe Text
-> Maybe ResourceStatus
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> CreateTemplateResponse
CreateTemplateResponse'
            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
"Arn")
            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
"CreationStatus")
            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
"RequestId")
            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
"TemplateId")
            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
"VersionArn")
            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 CreateTemplate where
  hashWithSalt :: Int -> CreateTemplate -> Int
hashWithSalt Int
_salt CreateTemplate' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe TemplateSourceEntity
Maybe TemplateVersionDefinition
Text
templateId :: Text
awsAccountId :: Text
versionDescription :: Maybe Text
tags :: Maybe (NonEmpty Tag)
sourceEntity :: Maybe TemplateSourceEntity
permissions :: Maybe (NonEmpty ResourcePermission)
name :: Maybe Text
definition :: Maybe TemplateVersionDefinition
$sel:templateId:CreateTemplate' :: CreateTemplate -> Text
$sel:awsAccountId:CreateTemplate' :: CreateTemplate -> Text
$sel:versionDescription:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:tags:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty Tag)
$sel:sourceEntity:CreateTemplate' :: CreateTemplate -> Maybe TemplateSourceEntity
$sel:permissions:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty ResourcePermission)
$sel:name:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:definition:CreateTemplate' :: CreateTemplate -> Maybe TemplateVersionDefinition
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TemplateVersionDefinition
definition
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty ResourcePermission)
permissions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TemplateSourceEntity
sourceEntity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
versionDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
awsAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
templateId

instance Prelude.NFData CreateTemplate where
  rnf :: CreateTemplate -> ()
rnf CreateTemplate' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe TemplateSourceEntity
Maybe TemplateVersionDefinition
Text
templateId :: Text
awsAccountId :: Text
versionDescription :: Maybe Text
tags :: Maybe (NonEmpty Tag)
sourceEntity :: Maybe TemplateSourceEntity
permissions :: Maybe (NonEmpty ResourcePermission)
name :: Maybe Text
definition :: Maybe TemplateVersionDefinition
$sel:templateId:CreateTemplate' :: CreateTemplate -> Text
$sel:awsAccountId:CreateTemplate' :: CreateTemplate -> Text
$sel:versionDescription:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:tags:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty Tag)
$sel:sourceEntity:CreateTemplate' :: CreateTemplate -> Maybe TemplateSourceEntity
$sel:permissions:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty ResourcePermission)
$sel:name:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:definition:CreateTemplate' :: CreateTemplate -> Maybe TemplateVersionDefinition
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe TemplateVersionDefinition
definition
      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 Maybe (NonEmpty ResourcePermission)
permissions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TemplateSourceEntity
sourceEntity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
versionDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
awsAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
templateId

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.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateTemplate where
  toJSON :: CreateTemplate -> Value
toJSON CreateTemplate' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe TemplateSourceEntity
Maybe TemplateVersionDefinition
Text
templateId :: Text
awsAccountId :: Text
versionDescription :: Maybe Text
tags :: Maybe (NonEmpty Tag)
sourceEntity :: Maybe TemplateSourceEntity
permissions :: Maybe (NonEmpty ResourcePermission)
name :: Maybe Text
definition :: Maybe TemplateVersionDefinition
$sel:templateId:CreateTemplate' :: CreateTemplate -> Text
$sel:awsAccountId:CreateTemplate' :: CreateTemplate -> Text
$sel:versionDescription:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:tags:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty Tag)
$sel:sourceEntity:CreateTemplate' :: CreateTemplate -> Maybe TemplateSourceEntity
$sel:permissions:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty ResourcePermission)
$sel:name:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:definition:CreateTemplate' :: CreateTemplate -> Maybe TemplateVersionDefinition
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Definition" 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 TemplateVersionDefinition
definition,
            (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,
            (Key
"Permissions" 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 (NonEmpty ResourcePermission)
permissions,
            (Key
"SourceEntity" 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 TemplateSourceEntity
sourceEntity,
            (Key
"Tags" 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 (NonEmpty Tag)
tags,
            (Key
"VersionDescription" 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
versionDescription
          ]
      )

instance Data.ToPath CreateTemplate where
  toPath :: CreateTemplate -> ByteString
toPath CreateTemplate' {Maybe (NonEmpty ResourcePermission)
Maybe (NonEmpty Tag)
Maybe Text
Maybe TemplateSourceEntity
Maybe TemplateVersionDefinition
Text
templateId :: Text
awsAccountId :: Text
versionDescription :: Maybe Text
tags :: Maybe (NonEmpty Tag)
sourceEntity :: Maybe TemplateSourceEntity
permissions :: Maybe (NonEmpty ResourcePermission)
name :: Maybe Text
definition :: Maybe TemplateVersionDefinition
$sel:templateId:CreateTemplate' :: CreateTemplate -> Text
$sel:awsAccountId:CreateTemplate' :: CreateTemplate -> Text
$sel:versionDescription:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:tags:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty Tag)
$sel:sourceEntity:CreateTemplate' :: CreateTemplate -> Maybe TemplateSourceEntity
$sel:permissions:CreateTemplate' :: CreateTemplate -> Maybe (NonEmpty ResourcePermission)
$sel:name:CreateTemplate' :: CreateTemplate -> Maybe Text
$sel:definition:CreateTemplate' :: CreateTemplate -> Maybe TemplateVersionDefinition
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/accounts/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
awsAccountId,
        ByteString
"/templates/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
templateId
      ]

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 ARN for the template.
    CreateTemplateResponse -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The template creation status.
    CreateTemplateResponse -> Maybe ResourceStatus
creationStatus :: Prelude.Maybe ResourceStatus,
    -- | The Amazon Web Services request ID for this operation.
    CreateTemplateResponse -> Maybe Text
requestId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the template.
    CreateTemplateResponse -> Maybe Text
templateId :: Prelude.Maybe Prelude.Text,
    -- | The ARN for the template, including the version information of the first
    -- version.
    CreateTemplateResponse -> Maybe Text
versionArn :: Prelude.Maybe Prelude.Text,
    -- | The HTTP status of the request.
    CreateTemplateResponse -> Int
status :: Prelude.Int
  }
  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:
--
-- 'arn', 'createTemplateResponse_arn' - The ARN for the template.
--
-- 'creationStatus', 'createTemplateResponse_creationStatus' - The template creation status.
--
-- 'requestId', 'createTemplateResponse_requestId' - The Amazon Web Services request ID for this operation.
--
-- 'templateId', 'createTemplateResponse_templateId' - The ID of the template.
--
-- 'versionArn', 'createTemplateResponse_versionArn' - The ARN for the template, including the version information of the first
-- version.
--
-- 'status', 'createTemplateResponse_status' - The HTTP status of the request.
newCreateTemplateResponse ::
  -- | 'status'
  Prelude.Int ->
  CreateTemplateResponse
newCreateTemplateResponse :: Int -> CreateTemplateResponse
newCreateTemplateResponse Int
pStatus_ =
  CreateTemplateResponse'
    { $sel:arn:CreateTemplateResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:creationStatus:CreateTemplateResponse' :: Maybe ResourceStatus
creationStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:requestId:CreateTemplateResponse' :: Maybe Text
requestId = forall a. Maybe a
Prelude.Nothing,
      $sel:templateId:CreateTemplateResponse' :: Maybe Text
templateId = forall a. Maybe a
Prelude.Nothing,
      $sel:versionArn:CreateTemplateResponse' :: Maybe Text
versionArn = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateTemplateResponse' :: Int
status = Int
pStatus_
    }

-- | The ARN for the template.
createTemplateResponse_arn :: Lens.Lens' CreateTemplateResponse (Prelude.Maybe Prelude.Text)
createTemplateResponse_arn :: Lens' CreateTemplateResponse (Maybe Text)
createTemplateResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Maybe Text
a -> CreateTemplateResponse
s {$sel:arn:CreateTemplateResponse' :: Maybe Text
arn = Maybe Text
a} :: CreateTemplateResponse)

-- | The template creation status.
createTemplateResponse_creationStatus :: Lens.Lens' CreateTemplateResponse (Prelude.Maybe ResourceStatus)
createTemplateResponse_creationStatus :: Lens' CreateTemplateResponse (Maybe ResourceStatus)
createTemplateResponse_creationStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Maybe ResourceStatus
creationStatus :: Maybe ResourceStatus
$sel:creationStatus:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe ResourceStatus
creationStatus} -> Maybe ResourceStatus
creationStatus) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Maybe ResourceStatus
a -> CreateTemplateResponse
s {$sel:creationStatus:CreateTemplateResponse' :: Maybe ResourceStatus
creationStatus = Maybe ResourceStatus
a} :: CreateTemplateResponse)

-- | The Amazon Web Services request ID for this operation.
createTemplateResponse_requestId :: Lens.Lens' CreateTemplateResponse (Prelude.Maybe Prelude.Text)
createTemplateResponse_requestId :: Lens' CreateTemplateResponse (Maybe Text)
createTemplateResponse_requestId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Maybe Text
requestId :: Maybe Text
$sel:requestId:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
requestId} -> Maybe Text
requestId) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Maybe Text
a -> CreateTemplateResponse
s {$sel:requestId:CreateTemplateResponse' :: Maybe Text
requestId = Maybe Text
a} :: CreateTemplateResponse)

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

-- | The ARN for the template, including the version information of the first
-- version.
createTemplateResponse_versionArn :: Lens.Lens' CreateTemplateResponse (Prelude.Maybe Prelude.Text)
createTemplateResponse_versionArn :: Lens' CreateTemplateResponse (Maybe Text)
createTemplateResponse_versionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Maybe Text
versionArn :: Maybe Text
$sel:versionArn:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
versionArn} -> Maybe Text
versionArn) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Maybe Text
a -> CreateTemplateResponse
s {$sel:versionArn:CreateTemplateResponse' :: Maybe Text
versionArn = Maybe Text
a} :: CreateTemplateResponse)

-- | The HTTP status of the request.
createTemplateResponse_status :: Lens.Lens' CreateTemplateResponse Prelude.Int
createTemplateResponse_status :: Lens' CreateTemplateResponse Int
createTemplateResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateTemplateResponse' {Int
status :: Int
$sel:status:CreateTemplateResponse' :: CreateTemplateResponse -> Int
status} -> Int
status) (\s :: CreateTemplateResponse
s@CreateTemplateResponse' {} Int
a -> CreateTemplateResponse
s {$sel:status:CreateTemplateResponse' :: Int
status = Int
a} :: CreateTemplateResponse)

instance Prelude.NFData CreateTemplateResponse where
  rnf :: CreateTemplateResponse -> ()
rnf CreateTemplateResponse' {Int
Maybe Text
Maybe ResourceStatus
status :: Int
versionArn :: Maybe Text
templateId :: Maybe Text
requestId :: Maybe Text
creationStatus :: Maybe ResourceStatus
arn :: Maybe Text
$sel:status:CreateTemplateResponse' :: CreateTemplateResponse -> Int
$sel:versionArn:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
$sel:templateId:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
$sel:requestId:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
$sel:creationStatus:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe ResourceStatus
$sel:arn:CreateTemplateResponse' :: CreateTemplateResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceStatus
creationStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
requestId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
templateId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
versionArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
status