{-# 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.UpdateBotAlias
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates the configuration of an existing bot alias.
module Amazonka.LexV2Models.UpdateBotAlias
  ( -- * Creating a Request
    UpdateBotAlias (..),
    newUpdateBotAlias,

    -- * Request Lenses
    updateBotAlias_botAliasLocaleSettings,
    updateBotAlias_botVersion,
    updateBotAlias_conversationLogSettings,
    updateBotAlias_description,
    updateBotAlias_sentimentAnalysisSettings,
    updateBotAlias_botAliasId,
    updateBotAlias_botAliasName,
    updateBotAlias_botId,

    -- * Destructuring the Response
    UpdateBotAliasResponse (..),
    newUpdateBotAliasResponse,

    -- * Response Lenses
    updateBotAliasResponse_botAliasId,
    updateBotAliasResponse_botAliasLocaleSettings,
    updateBotAliasResponse_botAliasName,
    updateBotAliasResponse_botAliasStatus,
    updateBotAliasResponse_botId,
    updateBotAliasResponse_botVersion,
    updateBotAliasResponse_conversationLogSettings,
    updateBotAliasResponse_creationDateTime,
    updateBotAliasResponse_description,
    updateBotAliasResponse_lastUpdatedDateTime,
    updateBotAliasResponse_sentimentAnalysisSettings,
    updateBotAliasResponse_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:/ 'newUpdateBotAlias' smart constructor.
data UpdateBotAlias = UpdateBotAlias'
  { -- | The new Lambda functions to use in each locale for the bot alias.
    UpdateBotAlias -> Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings :: Prelude.Maybe (Prelude.HashMap Prelude.Text BotAliasLocaleSettings),
    -- | The new bot version to assign to the bot alias.
    UpdateBotAlias -> Maybe Text
botVersion :: Prelude.Maybe Prelude.Text,
    -- | The new settings for storing conversation logs in Amazon CloudWatch Logs
    -- and Amazon S3 buckets.
    UpdateBotAlias -> Maybe ConversationLogSettings
conversationLogSettings :: Prelude.Maybe ConversationLogSettings,
    -- | The new description to assign to the bot alias.
    UpdateBotAlias -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    UpdateBotAlias -> Maybe SentimentAnalysisSettings
sentimentAnalysisSettings :: Prelude.Maybe SentimentAnalysisSettings,
    -- | The unique identifier of the bot alias.
    UpdateBotAlias -> Text
botAliasId :: Prelude.Text,
    -- | The new name to assign to the bot alias.
    UpdateBotAlias -> Text
botAliasName :: Prelude.Text,
    -- | The identifier of the bot with the updated alias.
    UpdateBotAlias -> Text
botId :: Prelude.Text
  }
  deriving (UpdateBotAlias -> UpdateBotAlias -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateBotAlias -> UpdateBotAlias -> Bool
$c/= :: UpdateBotAlias -> UpdateBotAlias -> Bool
== :: UpdateBotAlias -> UpdateBotAlias -> Bool
$c== :: UpdateBotAlias -> UpdateBotAlias -> Bool
Prelude.Eq, ReadPrec [UpdateBotAlias]
ReadPrec UpdateBotAlias
Int -> ReadS UpdateBotAlias
ReadS [UpdateBotAlias]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateBotAlias]
$creadListPrec :: ReadPrec [UpdateBotAlias]
readPrec :: ReadPrec UpdateBotAlias
$creadPrec :: ReadPrec UpdateBotAlias
readList :: ReadS [UpdateBotAlias]
$creadList :: ReadS [UpdateBotAlias]
readsPrec :: Int -> ReadS UpdateBotAlias
$creadsPrec :: Int -> ReadS UpdateBotAlias
Prelude.Read, Int -> UpdateBotAlias -> ShowS
[UpdateBotAlias] -> ShowS
UpdateBotAlias -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateBotAlias] -> ShowS
$cshowList :: [UpdateBotAlias] -> ShowS
show :: UpdateBotAlias -> String
$cshow :: UpdateBotAlias -> String
showsPrec :: Int -> UpdateBotAlias -> ShowS
$cshowsPrec :: Int -> UpdateBotAlias -> ShowS
Prelude.Show, forall x. Rep UpdateBotAlias x -> UpdateBotAlias
forall x. UpdateBotAlias -> Rep UpdateBotAlias x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateBotAlias x -> UpdateBotAlias
$cfrom :: forall x. UpdateBotAlias -> Rep UpdateBotAlias x
Prelude.Generic)

-- |
-- Create a value of 'UpdateBotAlias' 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:
--
-- 'botAliasLocaleSettings', 'updateBotAlias_botAliasLocaleSettings' - The new Lambda functions to use in each locale for the bot alias.
--
-- 'botVersion', 'updateBotAlias_botVersion' - The new bot version to assign to the bot alias.
--
-- 'conversationLogSettings', 'updateBotAlias_conversationLogSettings' - The new settings for storing conversation logs in Amazon CloudWatch Logs
-- and Amazon S3 buckets.
--
-- 'description', 'updateBotAlias_description' - The new description to assign to the bot alias.
--
-- 'sentimentAnalysisSettings', 'updateBotAlias_sentimentAnalysisSettings' - Undocumented member.
--
-- 'botAliasId', 'updateBotAlias_botAliasId' - The unique identifier of the bot alias.
--
-- 'botAliasName', 'updateBotAlias_botAliasName' - The new name to assign to the bot alias.
--
-- 'botId', 'updateBotAlias_botId' - The identifier of the bot with the updated alias.
newUpdateBotAlias ::
  -- | 'botAliasId'
  Prelude.Text ->
  -- | 'botAliasName'
  Prelude.Text ->
  -- | 'botId'
  Prelude.Text ->
  UpdateBotAlias
newUpdateBotAlias :: Text -> Text -> Text -> UpdateBotAlias
newUpdateBotAlias Text
pBotAliasId_ Text
pBotAliasName_ Text
pBotId_ =
  UpdateBotAlias'
    { $sel:botAliasLocaleSettings:UpdateBotAlias' :: Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings =
        forall a. Maybe a
Prelude.Nothing,
      $sel:botVersion:UpdateBotAlias' :: Maybe Text
botVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:conversationLogSettings:UpdateBotAlias' :: Maybe ConversationLogSettings
conversationLogSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:description:UpdateBotAlias' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:sentimentAnalysisSettings:UpdateBotAlias' :: Maybe SentimentAnalysisSettings
sentimentAnalysisSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:botAliasId:UpdateBotAlias' :: Text
botAliasId = Text
pBotAliasId_,
      $sel:botAliasName:UpdateBotAlias' :: Text
botAliasName = Text
pBotAliasName_,
      $sel:botId:UpdateBotAlias' :: Text
botId = Text
pBotId_
    }

-- | The new Lambda functions to use in each locale for the bot alias.
updateBotAlias_botAliasLocaleSettings :: Lens.Lens' UpdateBotAlias (Prelude.Maybe (Prelude.HashMap Prelude.Text BotAliasLocaleSettings))
updateBotAlias_botAliasLocaleSettings :: Lens' UpdateBotAlias (Maybe (HashMap Text BotAliasLocaleSettings))
updateBotAlias_botAliasLocaleSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botAliasLocaleSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings} -> Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Maybe (HashMap Text BotAliasLocaleSettings)
a -> UpdateBotAlias
s {$sel:botAliasLocaleSettings:UpdateBotAlias' :: Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings = Maybe (HashMap Text BotAliasLocaleSettings)
a} :: UpdateBotAlias) 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 new bot version to assign to the bot alias.
updateBotAlias_botVersion :: Lens.Lens' UpdateBotAlias (Prelude.Maybe Prelude.Text)
updateBotAlias_botVersion :: Lens' UpdateBotAlias (Maybe Text)
updateBotAlias_botVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Maybe Text
botVersion :: Maybe Text
$sel:botVersion:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
botVersion} -> Maybe Text
botVersion) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Maybe Text
a -> UpdateBotAlias
s {$sel:botVersion:UpdateBotAlias' :: Maybe Text
botVersion = Maybe Text
a} :: UpdateBotAlias)

-- | The new settings for storing conversation logs in Amazon CloudWatch Logs
-- and Amazon S3 buckets.
updateBotAlias_conversationLogSettings :: Lens.Lens' UpdateBotAlias (Prelude.Maybe ConversationLogSettings)
updateBotAlias_conversationLogSettings :: Lens' UpdateBotAlias (Maybe ConversationLogSettings)
updateBotAlias_conversationLogSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Maybe ConversationLogSettings
conversationLogSettings :: Maybe ConversationLogSettings
$sel:conversationLogSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe ConversationLogSettings
conversationLogSettings} -> Maybe ConversationLogSettings
conversationLogSettings) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Maybe ConversationLogSettings
a -> UpdateBotAlias
s {$sel:conversationLogSettings:UpdateBotAlias' :: Maybe ConversationLogSettings
conversationLogSettings = Maybe ConversationLogSettings
a} :: UpdateBotAlias)

-- | The new description to assign to the bot alias.
updateBotAlias_description :: Lens.Lens' UpdateBotAlias (Prelude.Maybe Prelude.Text)
updateBotAlias_description :: Lens' UpdateBotAlias (Maybe Text)
updateBotAlias_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Maybe Text
description :: Maybe Text
$sel:description:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
description} -> Maybe Text
description) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Maybe Text
a -> UpdateBotAlias
s {$sel:description:UpdateBotAlias' :: Maybe Text
description = Maybe Text
a} :: UpdateBotAlias)

-- | Undocumented member.
updateBotAlias_sentimentAnalysisSettings :: Lens.Lens' UpdateBotAlias (Prelude.Maybe SentimentAnalysisSettings)
updateBotAlias_sentimentAnalysisSettings :: Lens' UpdateBotAlias (Maybe SentimentAnalysisSettings)
updateBotAlias_sentimentAnalysisSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Maybe SentimentAnalysisSettings
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
$sel:sentimentAnalysisSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe SentimentAnalysisSettings
sentimentAnalysisSettings} -> Maybe SentimentAnalysisSettings
sentimentAnalysisSettings) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Maybe SentimentAnalysisSettings
a -> UpdateBotAlias
s {$sel:sentimentAnalysisSettings:UpdateBotAlias' :: Maybe SentimentAnalysisSettings
sentimentAnalysisSettings = Maybe SentimentAnalysisSettings
a} :: UpdateBotAlias)

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

-- | The new name to assign to the bot alias.
updateBotAlias_botAliasName :: Lens.Lens' UpdateBotAlias Prelude.Text
updateBotAlias_botAliasName :: Lens' UpdateBotAlias Text
updateBotAlias_botAliasName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Text
botAliasName :: Text
$sel:botAliasName:UpdateBotAlias' :: UpdateBotAlias -> Text
botAliasName} -> Text
botAliasName) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Text
a -> UpdateBotAlias
s {$sel:botAliasName:UpdateBotAlias' :: Text
botAliasName = Text
a} :: UpdateBotAlias)

-- | The identifier of the bot with the updated alias.
updateBotAlias_botId :: Lens.Lens' UpdateBotAlias Prelude.Text
updateBotAlias_botId :: Lens' UpdateBotAlias Text
updateBotAlias_botId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAlias' {Text
botId :: Text
$sel:botId:UpdateBotAlias' :: UpdateBotAlias -> Text
botId} -> Text
botId) (\s :: UpdateBotAlias
s@UpdateBotAlias' {} Text
a -> UpdateBotAlias
s {$sel:botId:UpdateBotAlias' :: Text
botId = Text
a} :: UpdateBotAlias)

instance Core.AWSRequest UpdateBotAlias where
  type
    AWSResponse UpdateBotAlias =
      UpdateBotAliasResponse
  request :: (Service -> Service) -> UpdateBotAlias -> Request UpdateBotAlias
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.putJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy UpdateBotAlias
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse UpdateBotAlias)))
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 (HashMap Text BotAliasLocaleSettings)
-> Maybe Text
-> Maybe BotAliasStatus
-> Maybe Text
-> Maybe Text
-> Maybe ConversationLogSettings
-> Maybe POSIX
-> Maybe Text
-> Maybe POSIX
-> Maybe SentimentAnalysisSettings
-> Int
-> UpdateBotAliasResponse
UpdateBotAliasResponse'
            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
"botAliasLocaleSettings"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            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
"botAliasName")
            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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"botVersion")
            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
"conversationLogSettings")
            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
"creationDateTime")
            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
"description")
            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
"lastUpdatedDateTime")
            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
"sentimentAnalysisSettings")
            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 UpdateBotAlias where
  hashWithSalt :: Int -> UpdateBotAlias -> Int
hashWithSalt Int
_salt UpdateBotAlias' {Maybe Text
Maybe (HashMap Text BotAliasLocaleSettings)
Maybe SentimentAnalysisSettings
Maybe ConversationLogSettings
Text
botId :: Text
botAliasName :: Text
botAliasId :: Text
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
description :: Maybe Text
conversationLogSettings :: Maybe ConversationLogSettings
botVersion :: Maybe Text
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasName:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:sentimentAnalysisSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe SentimentAnalysisSettings
$sel:description:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:conversationLogSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe ConversationLogSettings
$sel:botVersion:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:botAliasLocaleSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe (HashMap Text BotAliasLocaleSettings)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
botVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ConversationLogSettings
conversationLogSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SentimentAnalysisSettings
sentimentAnalysisSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botAliasId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botAliasName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botId

instance Prelude.NFData UpdateBotAlias where
  rnf :: UpdateBotAlias -> ()
rnf UpdateBotAlias' {Maybe Text
Maybe (HashMap Text BotAliasLocaleSettings)
Maybe SentimentAnalysisSettings
Maybe ConversationLogSettings
Text
botId :: Text
botAliasName :: Text
botAliasId :: Text
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
description :: Maybe Text
conversationLogSettings :: Maybe ConversationLogSettings
botVersion :: Maybe Text
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasName:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:sentimentAnalysisSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe SentimentAnalysisSettings
$sel:description:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:conversationLogSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe ConversationLogSettings
$sel:botVersion:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:botAliasLocaleSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe (HashMap Text BotAliasLocaleSettings)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
botVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConversationLogSettings
conversationLogSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SentimentAnalysisSettings
sentimentAnalysisSettings
      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
botAliasName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
botId

instance Data.ToHeaders UpdateBotAlias where
  toHeaders :: UpdateBotAlias -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON UpdateBotAlias where
  toJSON :: UpdateBotAlias -> Value
toJSON UpdateBotAlias' {Maybe Text
Maybe (HashMap Text BotAliasLocaleSettings)
Maybe SentimentAnalysisSettings
Maybe ConversationLogSettings
Text
botId :: Text
botAliasName :: Text
botAliasId :: Text
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
description :: Maybe Text
conversationLogSettings :: Maybe ConversationLogSettings
botVersion :: Maybe Text
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasName:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:sentimentAnalysisSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe SentimentAnalysisSettings
$sel:description:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:conversationLogSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe ConversationLogSettings
$sel:botVersion:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:botAliasLocaleSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe (HashMap Text BotAliasLocaleSettings)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"botAliasLocaleSettings" 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 (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings,
            (Key
"botVersion" 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
botVersion,
            (Key
"conversationLogSettings" 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 ConversationLogSettings
conversationLogSettings,
            (Key
"description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Key
"sentimentAnalysisSettings" 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 SentimentAnalysisSettings
sentimentAnalysisSettings,
            forall a. a -> Maybe a
Prelude.Just (Key
"botAliasName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
botAliasName)
          ]
      )

instance Data.ToPath UpdateBotAlias where
  toPath :: UpdateBotAlias -> ByteString
toPath UpdateBotAlias' {Maybe Text
Maybe (HashMap Text BotAliasLocaleSettings)
Maybe SentimentAnalysisSettings
Maybe ConversationLogSettings
Text
botId :: Text
botAliasName :: Text
botAliasId :: Text
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
description :: Maybe Text
conversationLogSettings :: Maybe ConversationLogSettings
botVersion :: Maybe Text
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasName:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:botAliasId:UpdateBotAlias' :: UpdateBotAlias -> Text
$sel:sentimentAnalysisSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe SentimentAnalysisSettings
$sel:description:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:conversationLogSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe ConversationLogSettings
$sel:botVersion:UpdateBotAlias' :: UpdateBotAlias -> Maybe Text
$sel:botAliasLocaleSettings:UpdateBotAlias' :: UpdateBotAlias -> Maybe (HashMap Text BotAliasLocaleSettings)
..} =
    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 UpdateBotAlias where
  toQuery :: UpdateBotAlias -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newUpdateBotAliasResponse' smart constructor.
data UpdateBotAliasResponse = UpdateBotAliasResponse'
  { -- | The identifier of the updated bot alias.
    UpdateBotAliasResponse -> Maybe Text
botAliasId :: Prelude.Maybe Prelude.Text,
    -- | The updated Lambda functions to use in each locale for the bot alias.
    UpdateBotAliasResponse
-> Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings :: Prelude.Maybe (Prelude.HashMap Prelude.Text BotAliasLocaleSettings),
    -- | The updated name of the bot alias.
    UpdateBotAliasResponse -> Maybe Text
botAliasName :: Prelude.Maybe Prelude.Text,
    -- | The current status of the bot alias. When the status is @Available@ the
    -- alias is ready for use.
    UpdateBotAliasResponse -> Maybe BotAliasStatus
botAliasStatus :: Prelude.Maybe BotAliasStatus,
    -- | The identifier of the bot with the updated alias.
    UpdateBotAliasResponse -> Maybe Text
botId :: Prelude.Maybe Prelude.Text,
    -- | The updated version of the bot that the alias points to.
    UpdateBotAliasResponse -> Maybe Text
botVersion :: Prelude.Maybe Prelude.Text,
    -- | The updated settings for storing conversation logs in Amazon CloudWatch
    -- Logs and Amazon S3 buckets.
    UpdateBotAliasResponse -> Maybe ConversationLogSettings
conversationLogSettings :: Prelude.Maybe ConversationLogSettings,
    -- | A timestamp of the date and time that the bot was created.
    UpdateBotAliasResponse -> Maybe POSIX
creationDateTime :: Prelude.Maybe Data.POSIX,
    -- | The updated description of the bot alias.
    UpdateBotAliasResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | A timestamp of the date and time that the bot was last updated.
    UpdateBotAliasResponse -> Maybe POSIX
lastUpdatedDateTime :: Prelude.Maybe Data.POSIX,
    UpdateBotAliasResponse -> Maybe SentimentAnalysisSettings
sentimentAnalysisSettings :: Prelude.Maybe SentimentAnalysisSettings,
    -- | The response's http status code.
    UpdateBotAliasResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdateBotAliasResponse -> UpdateBotAliasResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateBotAliasResponse -> UpdateBotAliasResponse -> Bool
$c/= :: UpdateBotAliasResponse -> UpdateBotAliasResponse -> Bool
== :: UpdateBotAliasResponse -> UpdateBotAliasResponse -> Bool
$c== :: UpdateBotAliasResponse -> UpdateBotAliasResponse -> Bool
Prelude.Eq, ReadPrec [UpdateBotAliasResponse]
ReadPrec UpdateBotAliasResponse
Int -> ReadS UpdateBotAliasResponse
ReadS [UpdateBotAliasResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateBotAliasResponse]
$creadListPrec :: ReadPrec [UpdateBotAliasResponse]
readPrec :: ReadPrec UpdateBotAliasResponse
$creadPrec :: ReadPrec UpdateBotAliasResponse
readList :: ReadS [UpdateBotAliasResponse]
$creadList :: ReadS [UpdateBotAliasResponse]
readsPrec :: Int -> ReadS UpdateBotAliasResponse
$creadsPrec :: Int -> ReadS UpdateBotAliasResponse
Prelude.Read, Int -> UpdateBotAliasResponse -> ShowS
[UpdateBotAliasResponse] -> ShowS
UpdateBotAliasResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateBotAliasResponse] -> ShowS
$cshowList :: [UpdateBotAliasResponse] -> ShowS
show :: UpdateBotAliasResponse -> String
$cshow :: UpdateBotAliasResponse -> String
showsPrec :: Int -> UpdateBotAliasResponse -> ShowS
$cshowsPrec :: Int -> UpdateBotAliasResponse -> ShowS
Prelude.Show, forall x. Rep UpdateBotAliasResponse x -> UpdateBotAliasResponse
forall x. UpdateBotAliasResponse -> Rep UpdateBotAliasResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateBotAliasResponse x -> UpdateBotAliasResponse
$cfrom :: forall x. UpdateBotAliasResponse -> Rep UpdateBotAliasResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdateBotAliasResponse' 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', 'updateBotAliasResponse_botAliasId' - The identifier of the updated bot alias.
--
-- 'botAliasLocaleSettings', 'updateBotAliasResponse_botAliasLocaleSettings' - The updated Lambda functions to use in each locale for the bot alias.
--
-- 'botAliasName', 'updateBotAliasResponse_botAliasName' - The updated name of the bot alias.
--
-- 'botAliasStatus', 'updateBotAliasResponse_botAliasStatus' - The current status of the bot alias. When the status is @Available@ the
-- alias is ready for use.
--
-- 'botId', 'updateBotAliasResponse_botId' - The identifier of the bot with the updated alias.
--
-- 'botVersion', 'updateBotAliasResponse_botVersion' - The updated version of the bot that the alias points to.
--
-- 'conversationLogSettings', 'updateBotAliasResponse_conversationLogSettings' - The updated settings for storing conversation logs in Amazon CloudWatch
-- Logs and Amazon S3 buckets.
--
-- 'creationDateTime', 'updateBotAliasResponse_creationDateTime' - A timestamp of the date and time that the bot was created.
--
-- 'description', 'updateBotAliasResponse_description' - The updated description of the bot alias.
--
-- 'lastUpdatedDateTime', 'updateBotAliasResponse_lastUpdatedDateTime' - A timestamp of the date and time that the bot was last updated.
--
-- 'sentimentAnalysisSettings', 'updateBotAliasResponse_sentimentAnalysisSettings' - Undocumented member.
--
-- 'httpStatus', 'updateBotAliasResponse_httpStatus' - The response's http status code.
newUpdateBotAliasResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateBotAliasResponse
newUpdateBotAliasResponse :: Int -> UpdateBotAliasResponse
newUpdateBotAliasResponse Int
pHttpStatus_ =
  UpdateBotAliasResponse'
    { $sel:botAliasId:UpdateBotAliasResponse' :: Maybe Text
botAliasId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:botAliasLocaleSettings:UpdateBotAliasResponse' :: Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:botAliasName:UpdateBotAliasResponse' :: Maybe Text
botAliasName = forall a. Maybe a
Prelude.Nothing,
      $sel:botAliasStatus:UpdateBotAliasResponse' :: Maybe BotAliasStatus
botAliasStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:botId:UpdateBotAliasResponse' :: Maybe Text
botId = forall a. Maybe a
Prelude.Nothing,
      $sel:botVersion:UpdateBotAliasResponse' :: Maybe Text
botVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:conversationLogSettings:UpdateBotAliasResponse' :: Maybe ConversationLogSettings
conversationLogSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:creationDateTime:UpdateBotAliasResponse' :: Maybe POSIX
creationDateTime = forall a. Maybe a
Prelude.Nothing,
      $sel:description:UpdateBotAliasResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:lastUpdatedDateTime:UpdateBotAliasResponse' :: Maybe POSIX
lastUpdatedDateTime = forall a. Maybe a
Prelude.Nothing,
      $sel:sentimentAnalysisSettings:UpdateBotAliasResponse' :: Maybe SentimentAnalysisSettings
sentimentAnalysisSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateBotAliasResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

-- | The updated Lambda functions to use in each locale for the bot alias.
updateBotAliasResponse_botAliasLocaleSettings :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text BotAliasLocaleSettings))
updateBotAliasResponse_botAliasLocaleSettings :: Lens'
  UpdateBotAliasResponse
  (Maybe (HashMap Text BotAliasLocaleSettings))
updateBotAliasResponse_botAliasLocaleSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botAliasLocaleSettings:UpdateBotAliasResponse' :: UpdateBotAliasResponse
-> Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings} -> Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe (HashMap Text BotAliasLocaleSettings)
a -> UpdateBotAliasResponse
s {$sel:botAliasLocaleSettings:UpdateBotAliasResponse' :: Maybe (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings = Maybe (HashMap Text BotAliasLocaleSettings)
a} :: UpdateBotAliasResponse) 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 updated name of the bot alias.
updateBotAliasResponse_botAliasName :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe Prelude.Text)
updateBotAliasResponse_botAliasName :: Lens' UpdateBotAliasResponse (Maybe Text)
updateBotAliasResponse_botAliasName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe Text
botAliasName :: Maybe Text
$sel:botAliasName:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
botAliasName} -> Maybe Text
botAliasName) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe Text
a -> UpdateBotAliasResponse
s {$sel:botAliasName:UpdateBotAliasResponse' :: Maybe Text
botAliasName = Maybe Text
a} :: UpdateBotAliasResponse)

-- | The current status of the bot alias. When the status is @Available@ the
-- alias is ready for use.
updateBotAliasResponse_botAliasStatus :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe BotAliasStatus)
updateBotAliasResponse_botAliasStatus :: Lens' UpdateBotAliasResponse (Maybe BotAliasStatus)
updateBotAliasResponse_botAliasStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe BotAliasStatus
botAliasStatus :: Maybe BotAliasStatus
$sel:botAliasStatus:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe BotAliasStatus
botAliasStatus} -> Maybe BotAliasStatus
botAliasStatus) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe BotAliasStatus
a -> UpdateBotAliasResponse
s {$sel:botAliasStatus:UpdateBotAliasResponse' :: Maybe BotAliasStatus
botAliasStatus = Maybe BotAliasStatus
a} :: UpdateBotAliasResponse)

-- | The identifier of the bot with the updated alias.
updateBotAliasResponse_botId :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe Prelude.Text)
updateBotAliasResponse_botId :: Lens' UpdateBotAliasResponse (Maybe Text)
updateBotAliasResponse_botId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe Text
botId :: Maybe Text
$sel:botId:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
botId} -> Maybe Text
botId) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe Text
a -> UpdateBotAliasResponse
s {$sel:botId:UpdateBotAliasResponse' :: Maybe Text
botId = Maybe Text
a} :: UpdateBotAliasResponse)

-- | The updated version of the bot that the alias points to.
updateBotAliasResponse_botVersion :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe Prelude.Text)
updateBotAliasResponse_botVersion :: Lens' UpdateBotAliasResponse (Maybe Text)
updateBotAliasResponse_botVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe Text
botVersion :: Maybe Text
$sel:botVersion:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
botVersion} -> Maybe Text
botVersion) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe Text
a -> UpdateBotAliasResponse
s {$sel:botVersion:UpdateBotAliasResponse' :: Maybe Text
botVersion = Maybe Text
a} :: UpdateBotAliasResponse)

-- | The updated settings for storing conversation logs in Amazon CloudWatch
-- Logs and Amazon S3 buckets.
updateBotAliasResponse_conversationLogSettings :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe ConversationLogSettings)
updateBotAliasResponse_conversationLogSettings :: Lens' UpdateBotAliasResponse (Maybe ConversationLogSettings)
updateBotAliasResponse_conversationLogSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe ConversationLogSettings
conversationLogSettings :: Maybe ConversationLogSettings
$sel:conversationLogSettings:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe ConversationLogSettings
conversationLogSettings} -> Maybe ConversationLogSettings
conversationLogSettings) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe ConversationLogSettings
a -> UpdateBotAliasResponse
s {$sel:conversationLogSettings:UpdateBotAliasResponse' :: Maybe ConversationLogSettings
conversationLogSettings = Maybe ConversationLogSettings
a} :: UpdateBotAliasResponse)

-- | A timestamp of the date and time that the bot was created.
updateBotAliasResponse_creationDateTime :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe Prelude.UTCTime)
updateBotAliasResponse_creationDateTime :: Lens' UpdateBotAliasResponse (Maybe UTCTime)
updateBotAliasResponse_creationDateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe POSIX
creationDateTime :: Maybe POSIX
$sel:creationDateTime:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe POSIX
creationDateTime} -> Maybe POSIX
creationDateTime) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe POSIX
a -> UpdateBotAliasResponse
s {$sel:creationDateTime:UpdateBotAliasResponse' :: Maybe POSIX
creationDateTime = Maybe POSIX
a} :: UpdateBotAliasResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The updated description of the bot alias.
updateBotAliasResponse_description :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe Prelude.Text)
updateBotAliasResponse_description :: Lens' UpdateBotAliasResponse (Maybe Text)
updateBotAliasResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe Text
description :: Maybe Text
$sel:description:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe Text
a -> UpdateBotAliasResponse
s {$sel:description:UpdateBotAliasResponse' :: Maybe Text
description = Maybe Text
a} :: UpdateBotAliasResponse)

-- | A timestamp of the date and time that the bot was last updated.
updateBotAliasResponse_lastUpdatedDateTime :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe Prelude.UTCTime)
updateBotAliasResponse_lastUpdatedDateTime :: Lens' UpdateBotAliasResponse (Maybe UTCTime)
updateBotAliasResponse_lastUpdatedDateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe POSIX
lastUpdatedDateTime :: Maybe POSIX
$sel:lastUpdatedDateTime:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe POSIX
lastUpdatedDateTime} -> Maybe POSIX
lastUpdatedDateTime) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe POSIX
a -> UpdateBotAliasResponse
s {$sel:lastUpdatedDateTime:UpdateBotAliasResponse' :: Maybe POSIX
lastUpdatedDateTime = Maybe POSIX
a} :: UpdateBotAliasResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Undocumented member.
updateBotAliasResponse_sentimentAnalysisSettings :: Lens.Lens' UpdateBotAliasResponse (Prelude.Maybe SentimentAnalysisSettings)
updateBotAliasResponse_sentimentAnalysisSettings :: Lens' UpdateBotAliasResponse (Maybe SentimentAnalysisSettings)
updateBotAliasResponse_sentimentAnalysisSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateBotAliasResponse' {Maybe SentimentAnalysisSettings
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
$sel:sentimentAnalysisSettings:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe SentimentAnalysisSettings
sentimentAnalysisSettings} -> Maybe SentimentAnalysisSettings
sentimentAnalysisSettings) (\s :: UpdateBotAliasResponse
s@UpdateBotAliasResponse' {} Maybe SentimentAnalysisSettings
a -> UpdateBotAliasResponse
s {$sel:sentimentAnalysisSettings:UpdateBotAliasResponse' :: Maybe SentimentAnalysisSettings
sentimentAnalysisSettings = Maybe SentimentAnalysisSettings
a} :: UpdateBotAliasResponse)

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

instance Prelude.NFData UpdateBotAliasResponse where
  rnf :: UpdateBotAliasResponse -> ()
rnf UpdateBotAliasResponse' {Int
Maybe Text
Maybe (HashMap Text BotAliasLocaleSettings)
Maybe POSIX
Maybe BotAliasStatus
Maybe SentimentAnalysisSettings
Maybe ConversationLogSettings
httpStatus :: Int
sentimentAnalysisSettings :: Maybe SentimentAnalysisSettings
lastUpdatedDateTime :: Maybe POSIX
description :: Maybe Text
creationDateTime :: Maybe POSIX
conversationLogSettings :: Maybe ConversationLogSettings
botVersion :: Maybe Text
botId :: Maybe Text
botAliasStatus :: Maybe BotAliasStatus
botAliasName :: Maybe Text
botAliasLocaleSettings :: Maybe (HashMap Text BotAliasLocaleSettings)
botAliasId :: Maybe Text
$sel:httpStatus:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Int
$sel:sentimentAnalysisSettings:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe SentimentAnalysisSettings
$sel:lastUpdatedDateTime:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe POSIX
$sel:description:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
$sel:creationDateTime:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe POSIX
$sel:conversationLogSettings:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe ConversationLogSettings
$sel:botVersion:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
$sel:botId:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
$sel:botAliasStatus:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe BotAliasStatus
$sel:botAliasName:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> Maybe Text
$sel:botAliasLocaleSettings:UpdateBotAliasResponse' :: UpdateBotAliasResponse
-> Maybe (HashMap Text BotAliasLocaleSettings)
$sel:botAliasId:UpdateBotAliasResponse' :: UpdateBotAliasResponse -> 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 (HashMap Text BotAliasLocaleSettings)
botAliasLocaleSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
botAliasName
      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 Maybe Text
botVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConversationLogSettings
conversationLogSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
creationDateTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastUpdatedDateTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SentimentAnalysisSettings
sentimentAnalysisSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus