{-# 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.DeleteThemeAlias
-- 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 version of the theme that the specified theme alias points
-- to. If you provide a specific alias, you delete the version of the theme
-- that the alias points to.
module Amazonka.QuickSight.DeleteThemeAlias
  ( -- * Creating a Request
    DeleteThemeAlias (..),
    newDeleteThemeAlias,

    -- * Request Lenses
    deleteThemeAlias_awsAccountId,
    deleteThemeAlias_themeId,
    deleteThemeAlias_aliasName,

    -- * Destructuring the Response
    DeleteThemeAliasResponse (..),
    newDeleteThemeAliasResponse,

    -- * Response Lenses
    deleteThemeAliasResponse_aliasName,
    deleteThemeAliasResponse_arn,
    deleteThemeAliasResponse_requestId,
    deleteThemeAliasResponse_themeId,
    deleteThemeAliasResponse_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:/ 'newDeleteThemeAlias' smart constructor.
data DeleteThemeAlias = DeleteThemeAlias'
  { -- | The ID of the Amazon Web Services account that contains the theme alias
    -- to delete.
    DeleteThemeAlias -> Text
awsAccountId :: Prelude.Text,
    -- | The ID for the theme that the specified alias is for.
    DeleteThemeAlias -> Text
themeId :: Prelude.Text,
    -- | The unique name for the theme alias to delete.
    DeleteThemeAlias -> Text
aliasName :: Prelude.Text
  }
  deriving (DeleteThemeAlias -> DeleteThemeAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteThemeAlias -> DeleteThemeAlias -> Bool
$c/= :: DeleteThemeAlias -> DeleteThemeAlias -> Bool
== :: DeleteThemeAlias -> DeleteThemeAlias -> Bool
$c== :: DeleteThemeAlias -> DeleteThemeAlias -> Bool
Prelude.Eq, ReadPrec [DeleteThemeAlias]
ReadPrec DeleteThemeAlias
Int -> ReadS DeleteThemeAlias
ReadS [DeleteThemeAlias]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteThemeAlias]
$creadListPrec :: ReadPrec [DeleteThemeAlias]
readPrec :: ReadPrec DeleteThemeAlias
$creadPrec :: ReadPrec DeleteThemeAlias
readList :: ReadS [DeleteThemeAlias]
$creadList :: ReadS [DeleteThemeAlias]
readsPrec :: Int -> ReadS DeleteThemeAlias
$creadsPrec :: Int -> ReadS DeleteThemeAlias
Prelude.Read, Int -> DeleteThemeAlias -> ShowS
[DeleteThemeAlias] -> ShowS
DeleteThemeAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteThemeAlias] -> ShowS
$cshowList :: [DeleteThemeAlias] -> ShowS
show :: DeleteThemeAlias -> String
$cshow :: DeleteThemeAlias -> String
showsPrec :: Int -> DeleteThemeAlias -> ShowS
$cshowsPrec :: Int -> DeleteThemeAlias -> ShowS
Prelude.Show, forall x. Rep DeleteThemeAlias x -> DeleteThemeAlias
forall x. DeleteThemeAlias -> Rep DeleteThemeAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteThemeAlias x -> DeleteThemeAlias
$cfrom :: forall x. DeleteThemeAlias -> Rep DeleteThemeAlias x
Prelude.Generic)

-- |
-- Create a value of 'DeleteThemeAlias' 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', 'deleteThemeAlias_awsAccountId' - The ID of the Amazon Web Services account that contains the theme alias
-- to delete.
--
-- 'themeId', 'deleteThemeAlias_themeId' - The ID for the theme that the specified alias is for.
--
-- 'aliasName', 'deleteThemeAlias_aliasName' - The unique name for the theme alias to delete.
newDeleteThemeAlias ::
  -- | 'awsAccountId'
  Prelude.Text ->
  -- | 'themeId'
  Prelude.Text ->
  -- | 'aliasName'
  Prelude.Text ->
  DeleteThemeAlias
newDeleteThemeAlias :: Text -> Text -> Text -> DeleteThemeAlias
newDeleteThemeAlias
  Text
pAwsAccountId_
  Text
pThemeId_
  Text
pAliasName_ =
    DeleteThemeAlias'
      { $sel:awsAccountId:DeleteThemeAlias' :: Text
awsAccountId = Text
pAwsAccountId_,
        $sel:themeId:DeleteThemeAlias' :: Text
themeId = Text
pThemeId_,
        $sel:aliasName:DeleteThemeAlias' :: Text
aliasName = Text
pAliasName_
      }

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

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

-- | The unique name for the theme alias to delete.
deleteThemeAlias_aliasName :: Lens.Lens' DeleteThemeAlias Prelude.Text
deleteThemeAlias_aliasName :: Lens' DeleteThemeAlias Text
deleteThemeAlias_aliasName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteThemeAlias' {Text
aliasName :: Text
$sel:aliasName:DeleteThemeAlias' :: DeleteThemeAlias -> Text
aliasName} -> Text
aliasName) (\s :: DeleteThemeAlias
s@DeleteThemeAlias' {} Text
a -> DeleteThemeAlias
s {$sel:aliasName:DeleteThemeAlias' :: Text
aliasName = Text
a} :: DeleteThemeAlias)

instance Core.AWSRequest DeleteThemeAlias where
  type
    AWSResponse DeleteThemeAlias =
      DeleteThemeAliasResponse
  request :: (Service -> Service)
-> DeleteThemeAlias -> Request DeleteThemeAlias
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 DeleteThemeAlias
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteThemeAlias)))
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
-> DeleteThemeAliasResponse
DeleteThemeAliasResponse'
            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
"ThemeId")
            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 DeleteThemeAlias where
  hashWithSalt :: Int -> DeleteThemeAlias -> Int
hashWithSalt Int
_salt DeleteThemeAlias' {Text
aliasName :: Text
themeId :: Text
awsAccountId :: Text
$sel:aliasName:DeleteThemeAlias' :: DeleteThemeAlias -> Text
$sel:themeId:DeleteThemeAlias' :: DeleteThemeAlias -> Text
$sel:awsAccountId:DeleteThemeAlias' :: DeleteThemeAlias -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
awsAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
themeId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
aliasName

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

instance Data.ToHeaders DeleteThemeAlias where
  toHeaders :: DeleteThemeAlias -> 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 DeleteThemeAlias where
  toPath :: DeleteThemeAlias -> ByteString
toPath DeleteThemeAlias' {Text
aliasName :: Text
themeId :: Text
awsAccountId :: Text
$sel:aliasName:DeleteThemeAlias' :: DeleteThemeAlias -> Text
$sel:themeId:DeleteThemeAlias' :: DeleteThemeAlias -> Text
$sel:awsAccountId:DeleteThemeAlias' :: DeleteThemeAlias -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/accounts/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
awsAccountId,
        ByteString
"/themes/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
themeId,
        ByteString
"/aliases/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
aliasName
      ]

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

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

-- |
-- Create a value of 'DeleteThemeAliasResponse' 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', 'deleteThemeAliasResponse_aliasName' - The name for the theme alias.
--
-- 'arn', 'deleteThemeAliasResponse_arn' - The Amazon Resource Name (ARN) of the theme resource using the deleted
-- alias.
--
-- 'requestId', 'deleteThemeAliasResponse_requestId' - The Amazon Web Services request ID for this operation.
--
-- 'themeId', 'deleteThemeAliasResponse_themeId' - An ID for the theme associated with the deletion.
--
-- 'status', 'deleteThemeAliasResponse_status' - The HTTP status of the request.
newDeleteThemeAliasResponse ::
  -- | 'status'
  Prelude.Int ->
  DeleteThemeAliasResponse
newDeleteThemeAliasResponse :: Int -> DeleteThemeAliasResponse
newDeleteThemeAliasResponse Int
pStatus_ =
  DeleteThemeAliasResponse'
    { $sel:aliasName:DeleteThemeAliasResponse' :: Maybe Text
aliasName =
        forall a. Maybe a
Prelude.Nothing,
      $sel:arn:DeleteThemeAliasResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:requestId:DeleteThemeAliasResponse' :: Maybe Text
requestId = forall a. Maybe a
Prelude.Nothing,
      $sel:themeId:DeleteThemeAliasResponse' :: Maybe Text
themeId = forall a. Maybe a
Prelude.Nothing,
      $sel:status:DeleteThemeAliasResponse' :: Int
status = Int
pStatus_
    }

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

-- | The Amazon Resource Name (ARN) of the theme resource using the deleted
-- alias.
deleteThemeAliasResponse_arn :: Lens.Lens' DeleteThemeAliasResponse (Prelude.Maybe Prelude.Text)
deleteThemeAliasResponse_arn :: Lens' DeleteThemeAliasResponse (Maybe Text)
deleteThemeAliasResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteThemeAliasResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:DeleteThemeAliasResponse' :: DeleteThemeAliasResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: DeleteThemeAliasResponse
s@DeleteThemeAliasResponse' {} Maybe Text
a -> DeleteThemeAliasResponse
s {$sel:arn:DeleteThemeAliasResponse' :: Maybe Text
arn = Maybe Text
a} :: DeleteThemeAliasResponse)

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

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

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

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