{-# 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.CreateBotLocale
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a locale in the bot. The locale contains the intents and slot
-- types that the bot uses in conversations with users in the specified
-- language and locale. You must add a locale to a bot before you can add
-- intents and slot types to the bot.
module Amazonka.LexV2Models.CreateBotLocale
  ( -- * Creating a Request
    CreateBotLocale (..),
    newCreateBotLocale,

    -- * Request Lenses
    createBotLocale_description,
    createBotLocale_voiceSettings,
    createBotLocale_botId,
    createBotLocale_botVersion,
    createBotLocale_localeId,
    createBotLocale_nluIntentConfidenceThreshold,

    -- * Destructuring the Response
    CreateBotLocaleResponse (..),
    newCreateBotLocaleResponse,

    -- * Response Lenses
    createBotLocaleResponse_botId,
    createBotLocaleResponse_botLocaleStatus,
    createBotLocaleResponse_botVersion,
    createBotLocaleResponse_creationDateTime,
    createBotLocaleResponse_description,
    createBotLocaleResponse_localeId,
    createBotLocaleResponse_localeName,
    createBotLocaleResponse_nluIntentConfidenceThreshold,
    createBotLocaleResponse_voiceSettings,
    createBotLocaleResponse_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:/ 'newCreateBotLocale' smart constructor.
data CreateBotLocale = CreateBotLocale'
  { -- | A description of the bot locale. Use this to help identify the bot
    -- locale in lists.
    CreateBotLocale -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Polly voice ID that Amazon Lex uses for voice interaction
    -- with the user.
    CreateBotLocale -> Maybe VoiceSettings
voiceSettings :: Prelude.Maybe VoiceSettings,
    -- | The identifier of the bot to create the locale for.
    CreateBotLocale -> Text
botId :: Prelude.Text,
    -- | The version of the bot to create the locale for. This can only be the
    -- draft version of the bot.
    CreateBotLocale -> Text
botVersion :: Prelude.Text,
    -- | The identifier of the language and locale that the bot will be used in.
    -- The string must match one of the supported locales. All of the intents,
    -- slot types, and slots used in the bot must have the same locale. For
    -- more information, see
    -- <https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html Supported languages>.
    CreateBotLocale -> Text
localeId :: Prelude.Text,
    -- | Determines the threshold where Amazon Lex will insert the
    -- @AMAZON.FallbackIntent@, @AMAZON.KendraSearchIntent@, or both when
    -- returning alternative intents. @AMAZON.FallbackIntent@ and
    -- @AMAZON.KendraSearchIntent@ are only inserted if they are configured for
    -- the bot.
    --
    -- For example, suppose a bot is configured with the confidence threshold
    -- of 0.80 and the @AMAZON.FallbackIntent@. Amazon Lex returns three
    -- alternative intents with the following confidence scores: IntentA
    -- (0.70), IntentB (0.60), IntentC (0.50). The response from the
    -- @RecognizeText@ operation would be:
    --
    -- -   AMAZON.FallbackIntent
    --
    -- -   IntentA
    --
    -- -   IntentB
    --
    -- -   IntentC
    CreateBotLocale -> Double
nluIntentConfidenceThreshold :: Prelude.Double
  }
  deriving (CreateBotLocale -> CreateBotLocale -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateBotLocale -> CreateBotLocale -> Bool
$c/= :: CreateBotLocale -> CreateBotLocale -> Bool
== :: CreateBotLocale -> CreateBotLocale -> Bool
$c== :: CreateBotLocale -> CreateBotLocale -> Bool
Prelude.Eq, ReadPrec [CreateBotLocale]
ReadPrec CreateBotLocale
Int -> ReadS CreateBotLocale
ReadS [CreateBotLocale]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateBotLocale]
$creadListPrec :: ReadPrec [CreateBotLocale]
readPrec :: ReadPrec CreateBotLocale
$creadPrec :: ReadPrec CreateBotLocale
readList :: ReadS [CreateBotLocale]
$creadList :: ReadS [CreateBotLocale]
readsPrec :: Int -> ReadS CreateBotLocale
$creadsPrec :: Int -> ReadS CreateBotLocale
Prelude.Read, Int -> CreateBotLocale -> ShowS
[CreateBotLocale] -> ShowS
CreateBotLocale -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateBotLocale] -> ShowS
$cshowList :: [CreateBotLocale] -> ShowS
show :: CreateBotLocale -> String
$cshow :: CreateBotLocale -> String
showsPrec :: Int -> CreateBotLocale -> ShowS
$cshowsPrec :: Int -> CreateBotLocale -> ShowS
Prelude.Show, forall x. Rep CreateBotLocale x -> CreateBotLocale
forall x. CreateBotLocale -> Rep CreateBotLocale x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateBotLocale x -> CreateBotLocale
$cfrom :: forall x. CreateBotLocale -> Rep CreateBotLocale x
Prelude.Generic)

-- |
-- Create a value of 'CreateBotLocale' 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:
--
-- 'description', 'createBotLocale_description' - A description of the bot locale. Use this to help identify the bot
-- locale in lists.
--
-- 'voiceSettings', 'createBotLocale_voiceSettings' - The Amazon Polly voice ID that Amazon Lex uses for voice interaction
-- with the user.
--
-- 'botId', 'createBotLocale_botId' - The identifier of the bot to create the locale for.
--
-- 'botVersion', 'createBotLocale_botVersion' - The version of the bot to create the locale for. This can only be the
-- draft version of the bot.
--
-- 'localeId', 'createBotLocale_localeId' - The identifier of the language and locale that the bot will be used in.
-- The string must match one of the supported locales. All of the intents,
-- slot types, and slots used in the bot must have the same locale. For
-- more information, see
-- <https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html Supported languages>.
--
-- 'nluIntentConfidenceThreshold', 'createBotLocale_nluIntentConfidenceThreshold' - Determines the threshold where Amazon Lex will insert the
-- @AMAZON.FallbackIntent@, @AMAZON.KendraSearchIntent@, or both when
-- returning alternative intents. @AMAZON.FallbackIntent@ and
-- @AMAZON.KendraSearchIntent@ are only inserted if they are configured for
-- the bot.
--
-- For example, suppose a bot is configured with the confidence threshold
-- of 0.80 and the @AMAZON.FallbackIntent@. Amazon Lex returns three
-- alternative intents with the following confidence scores: IntentA
-- (0.70), IntentB (0.60), IntentC (0.50). The response from the
-- @RecognizeText@ operation would be:
--
-- -   AMAZON.FallbackIntent
--
-- -   IntentA
--
-- -   IntentB
--
-- -   IntentC
newCreateBotLocale ::
  -- | 'botId'
  Prelude.Text ->
  -- | 'botVersion'
  Prelude.Text ->
  -- | 'localeId'
  Prelude.Text ->
  -- | 'nluIntentConfidenceThreshold'
  Prelude.Double ->
  CreateBotLocale
newCreateBotLocale :: Text -> Text -> Text -> Double -> CreateBotLocale
newCreateBotLocale
  Text
pBotId_
  Text
pBotVersion_
  Text
pLocaleId_
  Double
pNluIntentConfidenceThreshold_ =
    CreateBotLocale'
      { $sel:description:CreateBotLocale' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:voiceSettings:CreateBotLocale' :: Maybe VoiceSettings
voiceSettings = forall a. Maybe a
Prelude.Nothing,
        $sel:botId:CreateBotLocale' :: Text
botId = Text
pBotId_,
        $sel:botVersion:CreateBotLocale' :: Text
botVersion = Text
pBotVersion_,
        $sel:localeId:CreateBotLocale' :: Text
localeId = Text
pLocaleId_,
        $sel:nluIntentConfidenceThreshold:CreateBotLocale' :: Double
nluIntentConfidenceThreshold =
          Double
pNluIntentConfidenceThreshold_
      }

-- | A description of the bot locale. Use this to help identify the bot
-- locale in lists.
createBotLocale_description :: Lens.Lens' CreateBotLocale (Prelude.Maybe Prelude.Text)
createBotLocale_description :: Lens' CreateBotLocale (Maybe Text)
createBotLocale_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocale' {Maybe Text
description :: Maybe Text
$sel:description:CreateBotLocale' :: CreateBotLocale -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateBotLocale
s@CreateBotLocale' {} Maybe Text
a -> CreateBotLocale
s {$sel:description:CreateBotLocale' :: Maybe Text
description = Maybe Text
a} :: CreateBotLocale)

-- | The Amazon Polly voice ID that Amazon Lex uses for voice interaction
-- with the user.
createBotLocale_voiceSettings :: Lens.Lens' CreateBotLocale (Prelude.Maybe VoiceSettings)
createBotLocale_voiceSettings :: Lens' CreateBotLocale (Maybe VoiceSettings)
createBotLocale_voiceSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocale' {Maybe VoiceSettings
voiceSettings :: Maybe VoiceSettings
$sel:voiceSettings:CreateBotLocale' :: CreateBotLocale -> Maybe VoiceSettings
voiceSettings} -> Maybe VoiceSettings
voiceSettings) (\s :: CreateBotLocale
s@CreateBotLocale' {} Maybe VoiceSettings
a -> CreateBotLocale
s {$sel:voiceSettings:CreateBotLocale' :: Maybe VoiceSettings
voiceSettings = Maybe VoiceSettings
a} :: CreateBotLocale)

-- | The identifier of the bot to create the locale for.
createBotLocale_botId :: Lens.Lens' CreateBotLocale Prelude.Text
createBotLocale_botId :: Lens' CreateBotLocale Text
createBotLocale_botId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocale' {Text
botId :: Text
$sel:botId:CreateBotLocale' :: CreateBotLocale -> Text
botId} -> Text
botId) (\s :: CreateBotLocale
s@CreateBotLocale' {} Text
a -> CreateBotLocale
s {$sel:botId:CreateBotLocale' :: Text
botId = Text
a} :: CreateBotLocale)

-- | The version of the bot to create the locale for. This can only be the
-- draft version of the bot.
createBotLocale_botVersion :: Lens.Lens' CreateBotLocale Prelude.Text
createBotLocale_botVersion :: Lens' CreateBotLocale Text
createBotLocale_botVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocale' {Text
botVersion :: Text
$sel:botVersion:CreateBotLocale' :: CreateBotLocale -> Text
botVersion} -> Text
botVersion) (\s :: CreateBotLocale
s@CreateBotLocale' {} Text
a -> CreateBotLocale
s {$sel:botVersion:CreateBotLocale' :: Text
botVersion = Text
a} :: CreateBotLocale)

-- | The identifier of the language and locale that the bot will be used in.
-- The string must match one of the supported locales. All of the intents,
-- slot types, and slots used in the bot must have the same locale. For
-- more information, see
-- <https://docs.aws.amazon.com/lexv2/latest/dg/how-languages.html Supported languages>.
createBotLocale_localeId :: Lens.Lens' CreateBotLocale Prelude.Text
createBotLocale_localeId :: Lens' CreateBotLocale Text
createBotLocale_localeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocale' {Text
localeId :: Text
$sel:localeId:CreateBotLocale' :: CreateBotLocale -> Text
localeId} -> Text
localeId) (\s :: CreateBotLocale
s@CreateBotLocale' {} Text
a -> CreateBotLocale
s {$sel:localeId:CreateBotLocale' :: Text
localeId = Text
a} :: CreateBotLocale)

-- | Determines the threshold where Amazon Lex will insert the
-- @AMAZON.FallbackIntent@, @AMAZON.KendraSearchIntent@, or both when
-- returning alternative intents. @AMAZON.FallbackIntent@ and
-- @AMAZON.KendraSearchIntent@ are only inserted if they are configured for
-- the bot.
--
-- For example, suppose a bot is configured with the confidence threshold
-- of 0.80 and the @AMAZON.FallbackIntent@. Amazon Lex returns three
-- alternative intents with the following confidence scores: IntentA
-- (0.70), IntentB (0.60), IntentC (0.50). The response from the
-- @RecognizeText@ operation would be:
--
-- -   AMAZON.FallbackIntent
--
-- -   IntentA
--
-- -   IntentB
--
-- -   IntentC
createBotLocale_nluIntentConfidenceThreshold :: Lens.Lens' CreateBotLocale Prelude.Double
createBotLocale_nluIntentConfidenceThreshold :: Lens' CreateBotLocale Double
createBotLocale_nluIntentConfidenceThreshold = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocale' {Double
nluIntentConfidenceThreshold :: Double
$sel:nluIntentConfidenceThreshold:CreateBotLocale' :: CreateBotLocale -> Double
nluIntentConfidenceThreshold} -> Double
nluIntentConfidenceThreshold) (\s :: CreateBotLocale
s@CreateBotLocale' {} Double
a -> CreateBotLocale
s {$sel:nluIntentConfidenceThreshold:CreateBotLocale' :: Double
nluIntentConfidenceThreshold = Double
a} :: CreateBotLocale)

instance Core.AWSRequest CreateBotLocale where
  type
    AWSResponse CreateBotLocale =
      CreateBotLocaleResponse
  request :: (Service -> Service) -> CreateBotLocale -> Request CreateBotLocale
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 CreateBotLocale
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateBotLocale)))
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 BotLocaleStatus
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Double
-> Maybe VoiceSettings
-> Int
-> CreateBotLocaleResponse
CreateBotLocaleResponse'
            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
"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
"botLocaleStatus")
            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
"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
"localeId")
            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
"localeName")
            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
"nluIntentConfidenceThreshold")
            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
"voiceSettings")
            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 CreateBotLocale where
  hashWithSalt :: Int -> CreateBotLocale -> Int
hashWithSalt Int
_salt CreateBotLocale' {Double
Maybe Text
Maybe VoiceSettings
Text
nluIntentConfidenceThreshold :: Double
localeId :: Text
botVersion :: Text
botId :: Text
voiceSettings :: Maybe VoiceSettings
description :: Maybe Text
$sel:nluIntentConfidenceThreshold:CreateBotLocale' :: CreateBotLocale -> Double
$sel:localeId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botVersion:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:voiceSettings:CreateBotLocale' :: CreateBotLocale -> Maybe VoiceSettings
$sel:description:CreateBotLocale' :: CreateBotLocale -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VoiceSettings
voiceSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
localeId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Double
nluIntentConfidenceThreshold

instance Prelude.NFData CreateBotLocale where
  rnf :: CreateBotLocale -> ()
rnf CreateBotLocale' {Double
Maybe Text
Maybe VoiceSettings
Text
nluIntentConfidenceThreshold :: Double
localeId :: Text
botVersion :: Text
botId :: Text
voiceSettings :: Maybe VoiceSettings
description :: Maybe Text
$sel:nluIntentConfidenceThreshold:CreateBotLocale' :: CreateBotLocale -> Double
$sel:localeId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botVersion:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:voiceSettings:CreateBotLocale' :: CreateBotLocale -> Maybe VoiceSettings
$sel:description:CreateBotLocale' :: CreateBotLocale -> Maybe Text
..} =
    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 VoiceSettings
voiceSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
botId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
botVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
localeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Double
nluIntentConfidenceThreshold

instance Data.ToHeaders CreateBotLocale where
  toHeaders :: CreateBotLocale -> 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 CreateBotLocale where
  toJSON :: CreateBotLocale -> Value
toJSON CreateBotLocale' {Double
Maybe Text
Maybe VoiceSettings
Text
nluIntentConfidenceThreshold :: Double
localeId :: Text
botVersion :: Text
botId :: Text
voiceSettings :: Maybe VoiceSettings
description :: Maybe Text
$sel:nluIntentConfidenceThreshold:CreateBotLocale' :: CreateBotLocale -> Double
$sel:localeId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botVersion:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:voiceSettings:CreateBotLocale' :: CreateBotLocale -> Maybe VoiceSettings
$sel:description:CreateBotLocale' :: CreateBotLocale -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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
"voiceSettings" 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 VoiceSettings
voiceSettings,
            forall a. a -> Maybe a
Prelude.Just (Key
"localeId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
localeId),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"nluIntentConfidenceThreshold"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Double
nluIntentConfidenceThreshold
              )
          ]
      )

instance Data.ToPath CreateBotLocale where
  toPath :: CreateBotLocale -> ByteString
toPath CreateBotLocale' {Double
Maybe Text
Maybe VoiceSettings
Text
nluIntentConfidenceThreshold :: Double
localeId :: Text
botVersion :: Text
botId :: Text
voiceSettings :: Maybe VoiceSettings
description :: Maybe Text
$sel:nluIntentConfidenceThreshold:CreateBotLocale' :: CreateBotLocale -> Double
$sel:localeId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botVersion:CreateBotLocale' :: CreateBotLocale -> Text
$sel:botId:CreateBotLocale' :: CreateBotLocale -> Text
$sel:voiceSettings:CreateBotLocale' :: CreateBotLocale -> Maybe VoiceSettings
$sel:description:CreateBotLocale' :: CreateBotLocale -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/bots/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
botId,
        ByteString
"/botversions/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
botVersion,
        ByteString
"/botlocales/"
      ]

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

-- | /See:/ 'newCreateBotLocaleResponse' smart constructor.
data CreateBotLocaleResponse = CreateBotLocaleResponse'
  { -- | The specified bot identifier.
    CreateBotLocaleResponse -> Maybe Text
botId :: Prelude.Maybe Prelude.Text,
    -- | The status of the bot.
    --
    -- When the status is @Creating@ the bot locale is being configured. When
    -- the status is @Building@ Amazon Lex is building the bot for testing and
    -- use.
    --
    -- If the status of the bot is @ReadyExpressTesting@, you can test the bot
    -- using the exact utterances specified in the bots\' intents. When the bot
    -- is ready for full testing or to run, the status is @Built@.
    --
    -- If there was a problem with building the bot, the status is @Failed@. If
    -- the bot was saved but not built, the status is @NotBuilt@.
    CreateBotLocaleResponse -> Maybe BotLocaleStatus
botLocaleStatus :: Prelude.Maybe BotLocaleStatus,
    -- | The specified bot version.
    CreateBotLocaleResponse -> Maybe Text
botVersion :: Prelude.Maybe Prelude.Text,
    -- | A timestamp specifying the date and time that the bot locale was
    -- created.
    CreateBotLocaleResponse -> Maybe POSIX
creationDateTime :: Prelude.Maybe Data.POSIX,
    -- | The specified description of the bot locale.
    CreateBotLocaleResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The specified locale identifier.
    CreateBotLocaleResponse -> Maybe Text
localeId :: Prelude.Maybe Prelude.Text,
    -- | The specified locale name.
    CreateBotLocaleResponse -> Maybe Text
localeName :: Prelude.Maybe Prelude.Text,
    -- | The specified confidence threshold for inserting the
    -- @AMAZON.FallbackIntent@ and @AMAZON.KendraSearchIntent@ intents.
    CreateBotLocaleResponse -> Maybe Double
nluIntentConfidenceThreshold :: Prelude.Maybe Prelude.Double,
    -- | The Amazon Polly voice ID that Amazon Lex uses for voice interaction
    -- with the user.
    CreateBotLocaleResponse -> Maybe VoiceSettings
voiceSettings :: Prelude.Maybe VoiceSettings,
    -- | The response's http status code.
    CreateBotLocaleResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateBotLocaleResponse -> CreateBotLocaleResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateBotLocaleResponse -> CreateBotLocaleResponse -> Bool
$c/= :: CreateBotLocaleResponse -> CreateBotLocaleResponse -> Bool
== :: CreateBotLocaleResponse -> CreateBotLocaleResponse -> Bool
$c== :: CreateBotLocaleResponse -> CreateBotLocaleResponse -> Bool
Prelude.Eq, ReadPrec [CreateBotLocaleResponse]
ReadPrec CreateBotLocaleResponse
Int -> ReadS CreateBotLocaleResponse
ReadS [CreateBotLocaleResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateBotLocaleResponse]
$creadListPrec :: ReadPrec [CreateBotLocaleResponse]
readPrec :: ReadPrec CreateBotLocaleResponse
$creadPrec :: ReadPrec CreateBotLocaleResponse
readList :: ReadS [CreateBotLocaleResponse]
$creadList :: ReadS [CreateBotLocaleResponse]
readsPrec :: Int -> ReadS CreateBotLocaleResponse
$creadsPrec :: Int -> ReadS CreateBotLocaleResponse
Prelude.Read, Int -> CreateBotLocaleResponse -> ShowS
[CreateBotLocaleResponse] -> ShowS
CreateBotLocaleResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateBotLocaleResponse] -> ShowS
$cshowList :: [CreateBotLocaleResponse] -> ShowS
show :: CreateBotLocaleResponse -> String
$cshow :: CreateBotLocaleResponse -> String
showsPrec :: Int -> CreateBotLocaleResponse -> ShowS
$cshowsPrec :: Int -> CreateBotLocaleResponse -> ShowS
Prelude.Show, forall x. Rep CreateBotLocaleResponse x -> CreateBotLocaleResponse
forall x. CreateBotLocaleResponse -> Rep CreateBotLocaleResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateBotLocaleResponse x -> CreateBotLocaleResponse
$cfrom :: forall x. CreateBotLocaleResponse -> Rep CreateBotLocaleResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateBotLocaleResponse' 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:
--
-- 'botId', 'createBotLocaleResponse_botId' - The specified bot identifier.
--
-- 'botLocaleStatus', 'createBotLocaleResponse_botLocaleStatus' - The status of the bot.
--
-- When the status is @Creating@ the bot locale is being configured. When
-- the status is @Building@ Amazon Lex is building the bot for testing and
-- use.
--
-- If the status of the bot is @ReadyExpressTesting@, you can test the bot
-- using the exact utterances specified in the bots\' intents. When the bot
-- is ready for full testing or to run, the status is @Built@.
--
-- If there was a problem with building the bot, the status is @Failed@. If
-- the bot was saved but not built, the status is @NotBuilt@.
--
-- 'botVersion', 'createBotLocaleResponse_botVersion' - The specified bot version.
--
-- 'creationDateTime', 'createBotLocaleResponse_creationDateTime' - A timestamp specifying the date and time that the bot locale was
-- created.
--
-- 'description', 'createBotLocaleResponse_description' - The specified description of the bot locale.
--
-- 'localeId', 'createBotLocaleResponse_localeId' - The specified locale identifier.
--
-- 'localeName', 'createBotLocaleResponse_localeName' - The specified locale name.
--
-- 'nluIntentConfidenceThreshold', 'createBotLocaleResponse_nluIntentConfidenceThreshold' - The specified confidence threshold for inserting the
-- @AMAZON.FallbackIntent@ and @AMAZON.KendraSearchIntent@ intents.
--
-- 'voiceSettings', 'createBotLocaleResponse_voiceSettings' - The Amazon Polly voice ID that Amazon Lex uses for voice interaction
-- with the user.
--
-- 'httpStatus', 'createBotLocaleResponse_httpStatus' - The response's http status code.
newCreateBotLocaleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateBotLocaleResponse
newCreateBotLocaleResponse :: Int -> CreateBotLocaleResponse
newCreateBotLocaleResponse Int
pHttpStatus_ =
  CreateBotLocaleResponse'
    { $sel:botId:CreateBotLocaleResponse' :: Maybe Text
botId = forall a. Maybe a
Prelude.Nothing,
      $sel:botLocaleStatus:CreateBotLocaleResponse' :: Maybe BotLocaleStatus
botLocaleStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:botVersion:CreateBotLocaleResponse' :: Maybe Text
botVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:creationDateTime:CreateBotLocaleResponse' :: Maybe POSIX
creationDateTime = forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateBotLocaleResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:localeId:CreateBotLocaleResponse' :: Maybe Text
localeId = forall a. Maybe a
Prelude.Nothing,
      $sel:localeName:CreateBotLocaleResponse' :: Maybe Text
localeName = forall a. Maybe a
Prelude.Nothing,
      $sel:nluIntentConfidenceThreshold:CreateBotLocaleResponse' :: Maybe Double
nluIntentConfidenceThreshold = forall a. Maybe a
Prelude.Nothing,
      $sel:voiceSettings:CreateBotLocaleResponse' :: Maybe VoiceSettings
voiceSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateBotLocaleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The specified bot identifier.
createBotLocaleResponse_botId :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.Text)
createBotLocaleResponse_botId :: Lens' CreateBotLocaleResponse (Maybe Text)
createBotLocaleResponse_botId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe Text
botId :: Maybe Text
$sel:botId:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
botId} -> Maybe Text
botId) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe Text
a -> CreateBotLocaleResponse
s {$sel:botId:CreateBotLocaleResponse' :: Maybe Text
botId = Maybe Text
a} :: CreateBotLocaleResponse)

-- | The status of the bot.
--
-- When the status is @Creating@ the bot locale is being configured. When
-- the status is @Building@ Amazon Lex is building the bot for testing and
-- use.
--
-- If the status of the bot is @ReadyExpressTesting@, you can test the bot
-- using the exact utterances specified in the bots\' intents. When the bot
-- is ready for full testing or to run, the status is @Built@.
--
-- If there was a problem with building the bot, the status is @Failed@. If
-- the bot was saved but not built, the status is @NotBuilt@.
createBotLocaleResponse_botLocaleStatus :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe BotLocaleStatus)
createBotLocaleResponse_botLocaleStatus :: Lens' CreateBotLocaleResponse (Maybe BotLocaleStatus)
createBotLocaleResponse_botLocaleStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe BotLocaleStatus
botLocaleStatus :: Maybe BotLocaleStatus
$sel:botLocaleStatus:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe BotLocaleStatus
botLocaleStatus} -> Maybe BotLocaleStatus
botLocaleStatus) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe BotLocaleStatus
a -> CreateBotLocaleResponse
s {$sel:botLocaleStatus:CreateBotLocaleResponse' :: Maybe BotLocaleStatus
botLocaleStatus = Maybe BotLocaleStatus
a} :: CreateBotLocaleResponse)

-- | The specified bot version.
createBotLocaleResponse_botVersion :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.Text)
createBotLocaleResponse_botVersion :: Lens' CreateBotLocaleResponse (Maybe Text)
createBotLocaleResponse_botVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe Text
botVersion :: Maybe Text
$sel:botVersion:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
botVersion} -> Maybe Text
botVersion) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe Text
a -> CreateBotLocaleResponse
s {$sel:botVersion:CreateBotLocaleResponse' :: Maybe Text
botVersion = Maybe Text
a} :: CreateBotLocaleResponse)

-- | A timestamp specifying the date and time that the bot locale was
-- created.
createBotLocaleResponse_creationDateTime :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.UTCTime)
createBotLocaleResponse_creationDateTime :: Lens' CreateBotLocaleResponse (Maybe UTCTime)
createBotLocaleResponse_creationDateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe POSIX
creationDateTime :: Maybe POSIX
$sel:creationDateTime:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe POSIX
creationDateTime} -> Maybe POSIX
creationDateTime) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe POSIX
a -> CreateBotLocaleResponse
s {$sel:creationDateTime:CreateBotLocaleResponse' :: Maybe POSIX
creationDateTime = Maybe POSIX
a} :: CreateBotLocaleResponse) 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 specified description of the bot locale.
createBotLocaleResponse_description :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.Text)
createBotLocaleResponse_description :: Lens' CreateBotLocaleResponse (Maybe Text)
createBotLocaleResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe Text
description :: Maybe Text
$sel:description:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe Text
a -> CreateBotLocaleResponse
s {$sel:description:CreateBotLocaleResponse' :: Maybe Text
description = Maybe Text
a} :: CreateBotLocaleResponse)

-- | The specified locale identifier.
createBotLocaleResponse_localeId :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.Text)
createBotLocaleResponse_localeId :: Lens' CreateBotLocaleResponse (Maybe Text)
createBotLocaleResponse_localeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe Text
localeId :: Maybe Text
$sel:localeId:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
localeId} -> Maybe Text
localeId) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe Text
a -> CreateBotLocaleResponse
s {$sel:localeId:CreateBotLocaleResponse' :: Maybe Text
localeId = Maybe Text
a} :: CreateBotLocaleResponse)

-- | The specified locale name.
createBotLocaleResponse_localeName :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.Text)
createBotLocaleResponse_localeName :: Lens' CreateBotLocaleResponse (Maybe Text)
createBotLocaleResponse_localeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe Text
localeName :: Maybe Text
$sel:localeName:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
localeName} -> Maybe Text
localeName) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe Text
a -> CreateBotLocaleResponse
s {$sel:localeName:CreateBotLocaleResponse' :: Maybe Text
localeName = Maybe Text
a} :: CreateBotLocaleResponse)

-- | The specified confidence threshold for inserting the
-- @AMAZON.FallbackIntent@ and @AMAZON.KendraSearchIntent@ intents.
createBotLocaleResponse_nluIntentConfidenceThreshold :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe Prelude.Double)
createBotLocaleResponse_nluIntentConfidenceThreshold :: Lens' CreateBotLocaleResponse (Maybe Double)
createBotLocaleResponse_nluIntentConfidenceThreshold = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe Double
nluIntentConfidenceThreshold :: Maybe Double
$sel:nluIntentConfidenceThreshold:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Double
nluIntentConfidenceThreshold} -> Maybe Double
nluIntentConfidenceThreshold) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe Double
a -> CreateBotLocaleResponse
s {$sel:nluIntentConfidenceThreshold:CreateBotLocaleResponse' :: Maybe Double
nluIntentConfidenceThreshold = Maybe Double
a} :: CreateBotLocaleResponse)

-- | The Amazon Polly voice ID that Amazon Lex uses for voice interaction
-- with the user.
createBotLocaleResponse_voiceSettings :: Lens.Lens' CreateBotLocaleResponse (Prelude.Maybe VoiceSettings)
createBotLocaleResponse_voiceSettings :: Lens' CreateBotLocaleResponse (Maybe VoiceSettings)
createBotLocaleResponse_voiceSettings = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateBotLocaleResponse' {Maybe VoiceSettings
voiceSettings :: Maybe VoiceSettings
$sel:voiceSettings:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe VoiceSettings
voiceSettings} -> Maybe VoiceSettings
voiceSettings) (\s :: CreateBotLocaleResponse
s@CreateBotLocaleResponse' {} Maybe VoiceSettings
a -> CreateBotLocaleResponse
s {$sel:voiceSettings:CreateBotLocaleResponse' :: Maybe VoiceSettings
voiceSettings = Maybe VoiceSettings
a} :: CreateBotLocaleResponse)

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

instance Prelude.NFData CreateBotLocaleResponse where
  rnf :: CreateBotLocaleResponse -> ()
rnf CreateBotLocaleResponse' {Int
Maybe Double
Maybe Text
Maybe POSIX
Maybe BotLocaleStatus
Maybe VoiceSettings
httpStatus :: Int
voiceSettings :: Maybe VoiceSettings
nluIntentConfidenceThreshold :: Maybe Double
localeName :: Maybe Text
localeId :: Maybe Text
description :: Maybe Text
creationDateTime :: Maybe POSIX
botVersion :: Maybe Text
botLocaleStatus :: Maybe BotLocaleStatus
botId :: Maybe Text
$sel:httpStatus:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Int
$sel:voiceSettings:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe VoiceSettings
$sel:nluIntentConfidenceThreshold:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Double
$sel:localeName:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
$sel:localeId:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
$sel:description:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
$sel:creationDateTime:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe POSIX
$sel:botVersion:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
$sel:botLocaleStatus:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe BotLocaleStatus
$sel:botId:CreateBotLocaleResponse' :: CreateBotLocaleResponse -> Maybe Text
..} =
    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 BotLocaleStatus
botLocaleStatus
      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 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 Text
localeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
localeName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
nluIntentConfidenceThreshold
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VoiceSettings
voiceSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus