{-# 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.DeleteTemplateAlias
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the item that the specified template alias points to. If you
-- provide a specific alias, you delete the version of the template that
-- the alias points to.
module Amazonka.QuickSight.DeleteTemplateAlias
  ( -- * Creating a Request
    DeleteTemplateAlias (..),
    newDeleteTemplateAlias,

    -- * Request Lenses
    deleteTemplateAlias_awsAccountId,
    deleteTemplateAlias_templateId,
    deleteTemplateAlias_aliasName,

    -- * Destructuring the Response
    DeleteTemplateAliasResponse (..),
    newDeleteTemplateAliasResponse,

    -- * Response Lenses
    deleteTemplateAliasResponse_aliasName,
    deleteTemplateAliasResponse_arn,
    deleteTemplateAliasResponse_requestId,
    deleteTemplateAliasResponse_templateId,
    deleteTemplateAliasResponse_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:/ 'newDeleteTemplateAlias' smart constructor.
data DeleteTemplateAlias = DeleteTemplateAlias'
  { -- | The ID of the Amazon Web Services account that contains the item to
    -- delete.
    DeleteTemplateAlias -> Text
awsAccountId :: Prelude.Text,
    -- | The ID for the template that the specified alias is for.
    DeleteTemplateAlias -> Text
templateId :: Prelude.Text,
    -- | The name for the template alias. To delete a specific alias, you delete
    -- the version that the alias points to. You can specify the alias name, or
    -- specify the latest version of the template by providing the keyword
    -- @$LATEST@ in the @AliasName@ parameter.
    DeleteTemplateAlias -> Text
aliasName :: Prelude.Text
  }
  deriving (DeleteTemplateAlias -> DeleteTemplateAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTemplateAlias -> DeleteTemplateAlias -> Bool
$c/= :: DeleteTemplateAlias -> DeleteTemplateAlias -> Bool
== :: DeleteTemplateAlias -> DeleteTemplateAlias -> Bool
$c== :: DeleteTemplateAlias -> DeleteTemplateAlias -> Bool
Prelude.Eq, ReadPrec [DeleteTemplateAlias]
ReadPrec DeleteTemplateAlias
Int -> ReadS DeleteTemplateAlias
ReadS [DeleteTemplateAlias]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTemplateAlias]
$creadListPrec :: ReadPrec [DeleteTemplateAlias]
readPrec :: ReadPrec DeleteTemplateAlias
$creadPrec :: ReadPrec DeleteTemplateAlias
readList :: ReadS [DeleteTemplateAlias]
$creadList :: ReadS [DeleteTemplateAlias]
readsPrec :: Int -> ReadS DeleteTemplateAlias
$creadsPrec :: Int -> ReadS DeleteTemplateAlias
Prelude.Read, Int -> DeleteTemplateAlias -> ShowS
[DeleteTemplateAlias] -> ShowS
DeleteTemplateAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTemplateAlias] -> ShowS
$cshowList :: [DeleteTemplateAlias] -> ShowS
show :: DeleteTemplateAlias -> String
$cshow :: DeleteTemplateAlias -> String
showsPrec :: Int -> DeleteTemplateAlias -> ShowS
$cshowsPrec :: Int -> DeleteTemplateAlias -> ShowS
Prelude.Show, forall x. Rep DeleteTemplateAlias x -> DeleteTemplateAlias
forall x. DeleteTemplateAlias -> Rep DeleteTemplateAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteTemplateAlias x -> DeleteTemplateAlias
$cfrom :: forall x. DeleteTemplateAlias -> Rep DeleteTemplateAlias x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTemplateAlias' 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:
--
-- 'awsAccountId', 'deleteTemplateAlias_awsAccountId' - The ID of the Amazon Web Services account that contains the item to
-- delete.
--
-- 'templateId', 'deleteTemplateAlias_templateId' - The ID for the template that the specified alias is for.
--
-- 'aliasName', 'deleteTemplateAlias_aliasName' - The name for the template alias. To delete a specific alias, you delete
-- the version that the alias points to. You can specify the alias name, or
-- specify the latest version of the template by providing the keyword
-- @$LATEST@ in the @AliasName@ parameter.
newDeleteTemplateAlias ::
  -- | 'awsAccountId'
  Prelude.Text ->
  -- | 'templateId'
  Prelude.Text ->
  -- | 'aliasName'
  Prelude.Text ->
  DeleteTemplateAlias
newDeleteTemplateAlias :: Text -> Text -> Text -> DeleteTemplateAlias
newDeleteTemplateAlias
  Text
pAwsAccountId_
  Text
pTemplateId_
  Text
pAliasName_ =
    DeleteTemplateAlias'
      { $sel:awsAccountId:DeleteTemplateAlias' :: Text
awsAccountId = Text
pAwsAccountId_,
        $sel:templateId:DeleteTemplateAlias' :: Text
templateId = Text
pTemplateId_,
        $sel:aliasName:DeleteTemplateAlias' :: Text
aliasName = Text
pAliasName_
      }

-- | The ID of the Amazon Web Services account that contains the item to
-- delete.
deleteTemplateAlias_awsAccountId :: Lens.Lens' DeleteTemplateAlias Prelude.Text
deleteTemplateAlias_awsAccountId :: Lens' DeleteTemplateAlias Text
deleteTemplateAlias_awsAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTemplateAlias' {Text
awsAccountId :: Text
$sel:awsAccountId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
awsAccountId} -> Text
awsAccountId) (\s :: DeleteTemplateAlias
s@DeleteTemplateAlias' {} Text
a -> DeleteTemplateAlias
s {$sel:awsAccountId:DeleteTemplateAlias' :: Text
awsAccountId = Text
a} :: DeleteTemplateAlias)

-- | The ID for the template that the specified alias is for.
deleteTemplateAlias_templateId :: Lens.Lens' DeleteTemplateAlias Prelude.Text
deleteTemplateAlias_templateId :: Lens' DeleteTemplateAlias Text
deleteTemplateAlias_templateId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTemplateAlias' {Text
templateId :: Text
$sel:templateId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
templateId} -> Text
templateId) (\s :: DeleteTemplateAlias
s@DeleteTemplateAlias' {} Text
a -> DeleteTemplateAlias
s {$sel:templateId:DeleteTemplateAlias' :: Text
templateId = Text
a} :: DeleteTemplateAlias)

-- | The name for the template alias. To delete a specific alias, you delete
-- the version that the alias points to. You can specify the alias name, or
-- specify the latest version of the template by providing the keyword
-- @$LATEST@ in the @AliasName@ parameter.
deleteTemplateAlias_aliasName :: Lens.Lens' DeleteTemplateAlias Prelude.Text
deleteTemplateAlias_aliasName :: Lens' DeleteTemplateAlias Text
deleteTemplateAlias_aliasName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTemplateAlias' {Text
aliasName :: Text
$sel:aliasName:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
aliasName} -> Text
aliasName) (\s :: DeleteTemplateAlias
s@DeleteTemplateAlias' {} Text
a -> DeleteTemplateAlias
s {$sel:aliasName:DeleteTemplateAlias' :: Text
aliasName = Text
a} :: DeleteTemplateAlias)

instance Core.AWSRequest DeleteTemplateAlias where
  type
    AWSResponse DeleteTemplateAlias =
      DeleteTemplateAliasResponse
  request :: (Service -> Service)
-> DeleteTemplateAlias -> Request DeleteTemplateAlias
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.delete (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DeleteTemplateAlias
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeleteTemplateAlias)))
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 Text
-> Maybe Text
-> Maybe Text
-> Int
-> DeleteTemplateAliasResponse
DeleteTemplateAliasResponse'
            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
"AliasName")
            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
"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
"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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable DeleteTemplateAlias where
  hashWithSalt :: Int -> DeleteTemplateAlias -> Int
hashWithSalt Int
_salt DeleteTemplateAlias' {Text
aliasName :: Text
templateId :: Text
awsAccountId :: Text
$sel:aliasName:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
$sel:templateId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
$sel:awsAccountId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
awsAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
templateId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
aliasName

instance Prelude.NFData DeleteTemplateAlias where
  rnf :: DeleteTemplateAlias -> ()
rnf DeleteTemplateAlias' {Text
aliasName :: Text
templateId :: Text
awsAccountId :: Text
$sel:aliasName:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
$sel:templateId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
$sel:awsAccountId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
..} =
    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
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
aliasName

instance Data.ToHeaders DeleteTemplateAlias where
  toHeaders :: DeleteTemplateAlias -> 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.ToPath DeleteTemplateAlias where
  toPath :: DeleteTemplateAlias -> ByteString
toPath DeleteTemplateAlias' {Text
aliasName :: Text
templateId :: Text
awsAccountId :: Text
$sel:aliasName:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
$sel:templateId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
$sel:awsAccountId:DeleteTemplateAlias' :: DeleteTemplateAlias -> Text
..} =
    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,
        ByteString
"/aliases/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
aliasName
      ]

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

-- | /See:/ 'newDeleteTemplateAliasResponse' smart constructor.
data DeleteTemplateAliasResponse = DeleteTemplateAliasResponse'
  { -- | The name for the template alias.
    DeleteTemplateAliasResponse -> Maybe Text
aliasName :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the template you want to delete.
    DeleteTemplateAliasResponse -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Web Services request ID for this operation.
    DeleteTemplateAliasResponse -> Maybe Text
requestId :: Prelude.Maybe Prelude.Text,
    -- | An ID for the template associated with the deletion.
    DeleteTemplateAliasResponse -> Maybe Text
templateId :: Prelude.Maybe Prelude.Text,
    -- | The HTTP status of the request.
    DeleteTemplateAliasResponse -> Int
status :: Prelude.Int
  }
  deriving (DeleteTemplateAliasResponse -> DeleteTemplateAliasResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTemplateAliasResponse -> DeleteTemplateAliasResponse -> Bool
$c/= :: DeleteTemplateAliasResponse -> DeleteTemplateAliasResponse -> Bool
== :: DeleteTemplateAliasResponse -> DeleteTemplateAliasResponse -> Bool
$c== :: DeleteTemplateAliasResponse -> DeleteTemplateAliasResponse -> Bool
Prelude.Eq, ReadPrec [DeleteTemplateAliasResponse]
ReadPrec DeleteTemplateAliasResponse
Int -> ReadS DeleteTemplateAliasResponse
ReadS [DeleteTemplateAliasResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTemplateAliasResponse]
$creadListPrec :: ReadPrec [DeleteTemplateAliasResponse]
readPrec :: ReadPrec DeleteTemplateAliasResponse
$creadPrec :: ReadPrec DeleteTemplateAliasResponse
readList :: ReadS [DeleteTemplateAliasResponse]
$creadList :: ReadS [DeleteTemplateAliasResponse]
readsPrec :: Int -> ReadS DeleteTemplateAliasResponse
$creadsPrec :: Int -> ReadS DeleteTemplateAliasResponse
Prelude.Read, Int -> DeleteTemplateAliasResponse -> ShowS
[DeleteTemplateAliasResponse] -> ShowS
DeleteTemplateAliasResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTemplateAliasResponse] -> ShowS
$cshowList :: [DeleteTemplateAliasResponse] -> ShowS
show :: DeleteTemplateAliasResponse -> String
$cshow :: DeleteTemplateAliasResponse -> String
showsPrec :: Int -> DeleteTemplateAliasResponse -> ShowS
$cshowsPrec :: Int -> DeleteTemplateAliasResponse -> ShowS
Prelude.Show, forall x.
Rep DeleteTemplateAliasResponse x -> DeleteTemplateAliasResponse
forall x.
DeleteTemplateAliasResponse -> Rep DeleteTemplateAliasResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteTemplateAliasResponse x -> DeleteTemplateAliasResponse
$cfrom :: forall x.
DeleteTemplateAliasResponse -> Rep DeleteTemplateAliasResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTemplateAliasResponse' 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:
--
-- 'aliasName', 'deleteTemplateAliasResponse_aliasName' - The name for the template alias.
--
-- 'arn', 'deleteTemplateAliasResponse_arn' - The Amazon Resource Name (ARN) of the template you want to delete.
--
-- 'requestId', 'deleteTemplateAliasResponse_requestId' - The Amazon Web Services request ID for this operation.
--
-- 'templateId', 'deleteTemplateAliasResponse_templateId' - An ID for the template associated with the deletion.
--
-- 'status', 'deleteTemplateAliasResponse_status' - The HTTP status of the request.
newDeleteTemplateAliasResponse ::
  -- | 'status'
  Prelude.Int ->
  DeleteTemplateAliasResponse
newDeleteTemplateAliasResponse :: Int -> DeleteTemplateAliasResponse
newDeleteTemplateAliasResponse Int
pStatus_ =
  DeleteTemplateAliasResponse'
    { $sel:aliasName:DeleteTemplateAliasResponse' :: Maybe Text
aliasName =
        forall a. Maybe a
Prelude.Nothing,
      $sel:arn:DeleteTemplateAliasResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:requestId:DeleteTemplateAliasResponse' :: Maybe Text
requestId = forall a. Maybe a
Prelude.Nothing,
      $sel:templateId:DeleteTemplateAliasResponse' :: Maybe Text
templateId = forall a. Maybe a
Prelude.Nothing,
      $sel:status:DeleteTemplateAliasResponse' :: Int
status = Int
pStatus_
    }

-- | The name for the template alias.
deleteTemplateAliasResponse_aliasName :: Lens.Lens' DeleteTemplateAliasResponse (Prelude.Maybe Prelude.Text)
deleteTemplateAliasResponse_aliasName :: Lens' DeleteTemplateAliasResponse (Maybe Text)
deleteTemplateAliasResponse_aliasName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTemplateAliasResponse' {Maybe Text
aliasName :: Maybe Text
$sel:aliasName:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
aliasName} -> Maybe Text
aliasName) (\s :: DeleteTemplateAliasResponse
s@DeleteTemplateAliasResponse' {} Maybe Text
a -> DeleteTemplateAliasResponse
s {$sel:aliasName:DeleteTemplateAliasResponse' :: Maybe Text
aliasName = Maybe Text
a} :: DeleteTemplateAliasResponse)

-- | The Amazon Resource Name (ARN) of the template you want to delete.
deleteTemplateAliasResponse_arn :: Lens.Lens' DeleteTemplateAliasResponse (Prelude.Maybe Prelude.Text)
deleteTemplateAliasResponse_arn :: Lens' DeleteTemplateAliasResponse (Maybe Text)
deleteTemplateAliasResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTemplateAliasResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: DeleteTemplateAliasResponse
s@DeleteTemplateAliasResponse' {} Maybe Text
a -> DeleteTemplateAliasResponse
s {$sel:arn:DeleteTemplateAliasResponse' :: Maybe Text
arn = Maybe Text
a} :: DeleteTemplateAliasResponse)

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

-- | An ID for the template associated with the deletion.
deleteTemplateAliasResponse_templateId :: Lens.Lens' DeleteTemplateAliasResponse (Prelude.Maybe Prelude.Text)
deleteTemplateAliasResponse_templateId :: Lens' DeleteTemplateAliasResponse (Maybe Text)
deleteTemplateAliasResponse_templateId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTemplateAliasResponse' {Maybe Text
templateId :: Maybe Text
$sel:templateId:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
templateId} -> Maybe Text
templateId) (\s :: DeleteTemplateAliasResponse
s@DeleteTemplateAliasResponse' {} Maybe Text
a -> DeleteTemplateAliasResponse
s {$sel:templateId:DeleteTemplateAliasResponse' :: Maybe Text
templateId = Maybe Text
a} :: DeleteTemplateAliasResponse)

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

instance Prelude.NFData DeleteTemplateAliasResponse where
  rnf :: DeleteTemplateAliasResponse -> ()
rnf DeleteTemplateAliasResponse' {Int
Maybe Text
status :: Int
templateId :: Maybe Text
requestId :: Maybe Text
arn :: Maybe Text
aliasName :: Maybe Text
$sel:status:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Int
$sel:templateId:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
$sel:requestId:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
$sel:arn:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
$sel:aliasName:DeleteTemplateAliasResponse' :: DeleteTemplateAliasResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
aliasName
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 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 Int
status