{-# 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.LexV2Models.DeleteBotAlias
-- 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 specified bot alias.
module Amazonka.LexV2Models.DeleteBotAlias
  ( -- * Creating a Request
    DeleteBotAlias (..),
    newDeleteBotAlias,

    -- * Request Lenses
    deleteBotAlias_skipResourceInUseCheck,
    deleteBotAlias_botAliasId,
    deleteBotAlias_botId,

    -- * Destructuring the Response
    DeleteBotAliasResponse (..),
    newDeleteBotAliasResponse,

    -- * Response Lenses
    deleteBotAliasResponse_botAliasId,
    deleteBotAliasResponse_botAliasStatus,
    deleteBotAliasResponse_botId,
    deleteBotAliasResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.LexV2Models.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newDeleteBotAlias' smart constructor.
data DeleteBotAlias = DeleteBotAlias'
  { -- | When this parameter is true, Amazon Lex doesn\'t check to see if any
    -- other resource is using the alias before it is deleted.
    DeleteBotAlias -> Maybe Bool
skipResourceInUseCheck :: Prelude.Maybe Prelude.Bool,
    -- | The unique identifier of the bot alias to delete.
    DeleteBotAlias -> Text
botAliasId :: Prelude.Text,
    -- | The unique identifier of the bot associated with the alias to delete.
    DeleteBotAlias -> Text
botId :: Prelude.Text
  }
  deriving (DeleteBotAlias -> DeleteBotAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteBotAlias -> DeleteBotAlias -> Bool
$c/= :: DeleteBotAlias -> DeleteBotAlias -> Bool
== :: DeleteBotAlias -> DeleteBotAlias -> Bool
$c== :: DeleteBotAlias -> DeleteBotAlias -> Bool
Prelude.Eq, ReadPrec [DeleteBotAlias]
ReadPrec DeleteBotAlias
Int -> ReadS DeleteBotAlias
ReadS [DeleteBotAlias]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteBotAlias]
$creadListPrec :: ReadPrec [DeleteBotAlias]
readPrec :: ReadPrec DeleteBotAlias
$creadPrec :: ReadPrec DeleteBotAlias
readList :: ReadS [DeleteBotAlias]
$creadList :: ReadS [DeleteBotAlias]
readsPrec :: Int -> ReadS DeleteBotAlias
$creadsPrec :: Int -> ReadS DeleteBotAlias
Prelude.Read, Int -> DeleteBotAlias -> ShowS
[DeleteBotAlias] -> ShowS
DeleteBotAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteBotAlias] -> ShowS
$cshowList :: [DeleteBotAlias] -> ShowS
show :: DeleteBotAlias -> String
$cshow :: DeleteBotAlias -> String
showsPrec :: Int -> DeleteBotAlias -> ShowS
$cshowsPrec :: Int -> DeleteBotAlias -> ShowS
Prelude.Show, forall x. Rep DeleteBotAlias x -> DeleteBotAlias
forall x. DeleteBotAlias -> Rep DeleteBotAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteBotAlias x -> DeleteBotAlias
$cfrom :: forall x. DeleteBotAlias -> Rep DeleteBotAlias x
Prelude.Generic)

-- |
-- Create a value of 'DeleteBotAlias' 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:
--
-- 'skipResourceInUseCheck', 'deleteBotAlias_skipResourceInUseCheck' - When this parameter is true, Amazon Lex doesn\'t check to see if any
-- other resource is using the alias before it is deleted.
--
-- 'botAliasId', 'deleteBotAlias_botAliasId' - The unique identifier of the bot alias to delete.
--
-- 'botId', 'deleteBotAlias_botId' - The unique identifier of the bot associated with the alias to delete.
newDeleteBotAlias ::
  -- | 'botAliasId'
  Prelude.Text ->
  -- | 'botId'
  Prelude.Text ->
  DeleteBotAlias
newDeleteBotAlias :: Text -> Text -> DeleteBotAlias
newDeleteBotAlias Text
pBotAliasId_ Text
pBotId_ =
  DeleteBotAlias'
    { $sel:skipResourceInUseCheck:DeleteBotAlias' :: Maybe Bool
skipResourceInUseCheck =
        forall a. Maybe a
Prelude.Nothing,
      $sel:botAliasId:DeleteBotAlias' :: Text
botAliasId = Text
pBotAliasId_,
      $sel:botId:DeleteBotAlias' :: Text
botId = Text
pBotId_
    }

-- | When this parameter is true, Amazon Lex doesn\'t check to see if any
-- other resource is using the alias before it is deleted.
deleteBotAlias_skipResourceInUseCheck :: Lens.Lens' DeleteBotAlias (Prelude.Maybe Prelude.Bool)
deleteBotAlias_skipResourceInUseCheck :: Lens' DeleteBotAlias (Maybe Bool)
deleteBotAlias_skipResourceInUseCheck = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteBotAlias' {Maybe Bool
skipResourceInUseCheck :: Maybe Bool
$sel:skipResourceInUseCheck:DeleteBotAlias' :: DeleteBotAlias -> Maybe Bool
skipResourceInUseCheck} -> Maybe Bool
skipResourceInUseCheck) (\s :: DeleteBotAlias
s@DeleteBotAlias' {} Maybe Bool
a -> DeleteBotAlias
s {$sel:skipResourceInUseCheck:DeleteBotAlias' :: Maybe Bool
skipResourceInUseCheck = Maybe Bool
a} :: DeleteBotAlias)

-- | The unique identifier of the bot alias to delete.
deleteBotAlias_botAliasId :: Lens.Lens' DeleteBotAlias Prelude.Text
deleteBotAlias_botAliasId :: Lens' DeleteBotAlias Text
deleteBotAlias_botAliasId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteBotAlias' {Text
botAliasId :: Text
$sel:botAliasId:DeleteBotAlias' :: DeleteBotAlias -> Text
botAliasId} -> Text
botAliasId) (\s :: DeleteBotAlias
s@DeleteBotAlias' {} Text
a -> DeleteBotAlias
s {$sel:botAliasId:DeleteBotAlias' :: Text
botAliasId = Text
a} :: DeleteBotAlias)

-- | The unique identifier of the bot associated with the alias to delete.
deleteBotAlias_botId :: Lens.Lens' DeleteBotAlias Prelude.Text
deleteBotAlias_botId :: Lens' DeleteBotAlias Text
deleteBotAlias_botId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteBotAlias' {Text
botId :: Text
$sel:botId:DeleteBotAlias' :: DeleteBotAlias -> Text
botId} -> Text
botId) (\s :: DeleteBotAlias
s@DeleteBotAlias' {} Text
a -> DeleteBotAlias
s {$sel:botId:DeleteBotAlias' :: Text
botId = Text
a} :: DeleteBotAlias)

instance Core.AWSRequest DeleteBotAlias where
  type
    AWSResponse DeleteBotAlias =
      DeleteBotAliasResponse
  request :: (Service -> Service) -> DeleteBotAlias -> Request DeleteBotAlias
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 DeleteBotAlias
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteBotAlias)))
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 BotAliasStatus
-> Maybe Text
-> Int
-> DeleteBotAliasResponse
DeleteBotAliasResponse'
            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
"botAliasId")
            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
"botAliasStatus")
            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
"botId")
            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 DeleteBotAlias where
  hashWithSalt :: Int -> DeleteBotAlias -> Int
hashWithSalt Int
_salt DeleteBotAlias' {Maybe Bool
Text
botId :: Text
botAliasId :: Text
skipResourceInUseCheck :: Maybe Bool
$sel:botId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:botAliasId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:skipResourceInUseCheck:DeleteBotAlias' :: DeleteBotAlias -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
skipResourceInUseCheck
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botAliasId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botId

instance Prelude.NFData DeleteBotAlias where
  rnf :: DeleteBotAlias -> ()
rnf DeleteBotAlias' {Maybe Bool
Text
botId :: Text
botAliasId :: Text
skipResourceInUseCheck :: Maybe Bool
$sel:botId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:botAliasId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:skipResourceInUseCheck:DeleteBotAlias' :: DeleteBotAlias -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
skipResourceInUseCheck
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
botAliasId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
botId

instance Data.ToHeaders DeleteBotAlias where
  toHeaders :: DeleteBotAlias -> 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.ToPath DeleteBotAlias where
  toPath :: DeleteBotAlias -> ByteString
toPath DeleteBotAlias' {Maybe Bool
Text
botId :: Text
botAliasId :: Text
skipResourceInUseCheck :: Maybe Bool
$sel:botId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:botAliasId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:skipResourceInUseCheck:DeleteBotAlias' :: DeleteBotAlias -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/bots/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
botId,
        ByteString
"/botaliases/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
botAliasId,
        ByteString
"/"
      ]

instance Data.ToQuery DeleteBotAlias where
  toQuery :: DeleteBotAlias -> QueryString
toQuery DeleteBotAlias' {Maybe Bool
Text
botId :: Text
botAliasId :: Text
skipResourceInUseCheck :: Maybe Bool
$sel:botId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:botAliasId:DeleteBotAlias' :: DeleteBotAlias -> Text
$sel:skipResourceInUseCheck:DeleteBotAlias' :: DeleteBotAlias -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"skipResourceInUseCheck"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
skipResourceInUseCheck
      ]

-- | /See:/ 'newDeleteBotAliasResponse' smart constructor.
data DeleteBotAliasResponse = DeleteBotAliasResponse'
  { -- | The unique identifier of the bot alias to delete.
    DeleteBotAliasResponse -> Maybe Text
botAliasId :: Prelude.Maybe Prelude.Text,
    -- | The current status of the alias. The status is @Deleting@ while the
    -- alias is in the process of being deleted. Once the alias is deleted, it
    -- will no longer appear in the list of aliases returned by the
    -- @ListBotAliases@ operation.
    DeleteBotAliasResponse -> Maybe BotAliasStatus
botAliasStatus :: Prelude.Maybe BotAliasStatus,
    -- | The unique identifier of the bot that contains the alias to delete.
    DeleteBotAliasResponse -> Maybe Text
botId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    DeleteBotAliasResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DeleteBotAliasResponse -> DeleteBotAliasResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteBotAliasResponse -> DeleteBotAliasResponse -> Bool
$c/= :: DeleteBotAliasResponse -> DeleteBotAliasResponse -> Bool
== :: DeleteBotAliasResponse -> DeleteBotAliasResponse -> Bool
$c== :: DeleteBotAliasResponse -> DeleteBotAliasResponse -> Bool
Prelude.Eq, ReadPrec [DeleteBotAliasResponse]
ReadPrec DeleteBotAliasResponse
Int -> ReadS DeleteBotAliasResponse
ReadS [DeleteBotAliasResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteBotAliasResponse]
$creadListPrec :: ReadPrec [DeleteBotAliasResponse]
readPrec :: ReadPrec DeleteBotAliasResponse
$creadPrec :: ReadPrec DeleteBotAliasResponse
readList :: ReadS [DeleteBotAliasResponse]
$creadList :: ReadS [DeleteBotAliasResponse]
readsPrec :: Int -> ReadS DeleteBotAliasResponse
$creadsPrec :: Int -> ReadS DeleteBotAliasResponse
Prelude.Read, Int -> DeleteBotAliasResponse -> ShowS
[DeleteBotAliasResponse] -> ShowS
DeleteBotAliasResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteBotAliasResponse] -> ShowS
$cshowList :: [DeleteBotAliasResponse] -> ShowS
show :: DeleteBotAliasResponse -> String
$cshow :: DeleteBotAliasResponse -> String
showsPrec :: Int -> DeleteBotAliasResponse -> ShowS
$cshowsPrec :: Int -> DeleteBotAliasResponse -> ShowS
Prelude.Show, forall x. Rep DeleteBotAliasResponse x -> DeleteBotAliasResponse
forall x. DeleteBotAliasResponse -> Rep DeleteBotAliasResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteBotAliasResponse x -> DeleteBotAliasResponse
$cfrom :: forall x. DeleteBotAliasResponse -> Rep DeleteBotAliasResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteBotAliasResponse' 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:
--
-- 'botAliasId', 'deleteBotAliasResponse_botAliasId' - The unique identifier of the bot alias to delete.
--
-- 'botAliasStatus', 'deleteBotAliasResponse_botAliasStatus' - The current status of the alias. The status is @Deleting@ while the
-- alias is in the process of being deleted. Once the alias is deleted, it
-- will no longer appear in the list of aliases returned by the
-- @ListBotAliases@ operation.
--
-- 'botId', 'deleteBotAliasResponse_botId' - The unique identifier of the bot that contains the alias to delete.
--
-- 'httpStatus', 'deleteBotAliasResponse_httpStatus' - The response's http status code.
newDeleteBotAliasResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteBotAliasResponse
newDeleteBotAliasResponse :: Int -> DeleteBotAliasResponse
newDeleteBotAliasResponse Int
pHttpStatus_ =
  DeleteBotAliasResponse'
    { $sel:botAliasId:DeleteBotAliasResponse' :: Maybe Text
botAliasId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:botAliasStatus:DeleteBotAliasResponse' :: Maybe BotAliasStatus
botAliasStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:botId:DeleteBotAliasResponse' :: Maybe Text
botId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DeleteBotAliasResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The unique identifier of the bot alias to delete.
deleteBotAliasResponse_botAliasId :: Lens.Lens' DeleteBotAliasResponse (Prelude.Maybe Prelude.Text)
deleteBotAliasResponse_botAliasId :: Lens' DeleteBotAliasResponse (Maybe Text)
deleteBotAliasResponse_botAliasId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteBotAliasResponse' {Maybe Text
botAliasId :: Maybe Text
$sel:botAliasId:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Maybe Text
botAliasId} -> Maybe Text
botAliasId) (\s :: DeleteBotAliasResponse
s@DeleteBotAliasResponse' {} Maybe Text
a -> DeleteBotAliasResponse
s {$sel:botAliasId:DeleteBotAliasResponse' :: Maybe Text
botAliasId = Maybe Text
a} :: DeleteBotAliasResponse)

-- | The current status of the alias. The status is @Deleting@ while the
-- alias is in the process of being deleted. Once the alias is deleted, it
-- will no longer appear in the list of aliases returned by the
-- @ListBotAliases@ operation.
deleteBotAliasResponse_botAliasStatus :: Lens.Lens' DeleteBotAliasResponse (Prelude.Maybe BotAliasStatus)
deleteBotAliasResponse_botAliasStatus :: Lens' DeleteBotAliasResponse (Maybe BotAliasStatus)
deleteBotAliasResponse_botAliasStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteBotAliasResponse' {Maybe BotAliasStatus
botAliasStatus :: Maybe BotAliasStatus
$sel:botAliasStatus:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Maybe BotAliasStatus
botAliasStatus} -> Maybe BotAliasStatus
botAliasStatus) (\s :: DeleteBotAliasResponse
s@DeleteBotAliasResponse' {} Maybe BotAliasStatus
a -> DeleteBotAliasResponse
s {$sel:botAliasStatus:DeleteBotAliasResponse' :: Maybe BotAliasStatus
botAliasStatus = Maybe BotAliasStatus
a} :: DeleteBotAliasResponse)

-- | The unique identifier of the bot that contains the alias to delete.
deleteBotAliasResponse_botId :: Lens.Lens' DeleteBotAliasResponse (Prelude.Maybe Prelude.Text)
deleteBotAliasResponse_botId :: Lens' DeleteBotAliasResponse (Maybe Text)
deleteBotAliasResponse_botId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteBotAliasResponse' {Maybe Text
botId :: Maybe Text
$sel:botId:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Maybe Text
botId} -> Maybe Text
botId) (\s :: DeleteBotAliasResponse
s@DeleteBotAliasResponse' {} Maybe Text
a -> DeleteBotAliasResponse
s {$sel:botId:DeleteBotAliasResponse' :: Maybe Text
botId = Maybe Text
a} :: DeleteBotAliasResponse)

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

instance Prelude.NFData DeleteBotAliasResponse where
  rnf :: DeleteBotAliasResponse -> ()
rnf DeleteBotAliasResponse' {Int
Maybe Text
Maybe BotAliasStatus
httpStatus :: Int
botId :: Maybe Text
botAliasStatus :: Maybe BotAliasStatus
botAliasId :: Maybe Text
$sel:httpStatus:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Int
$sel:botId:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Maybe Text
$sel:botAliasStatus:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Maybe BotAliasStatus
$sel:botAliasId:DeleteBotAliasResponse' :: DeleteBotAliasResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
botAliasId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe BotAliasStatus
botAliasStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
botId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus