{-# 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.LexRuntime.PostText
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Sends user input to Amazon Lex. Client applications can use this API to
-- send requests to Amazon Lex at runtime. Amazon Lex then interprets the
-- user input using the machine learning model it built for the bot.
--
-- In response, Amazon Lex returns the next @message@ to convey to the user
-- an optional @responseCard@ to display. Consider the following example
-- messages:
--
-- -   For a user input \"I would like a pizza\", Amazon Lex might return a
--     response with a message eliciting slot data (for example,
--     PizzaSize): \"What size pizza would you like?\"
--
-- -   After the user provides all of the pizza order information, Amazon
--     Lex might return a response with a message to obtain user
--     confirmation \"Proceed with the pizza order?\".
--
-- -   After the user replies to a confirmation prompt with a \"yes\",
--     Amazon Lex might return a conclusion statement: \"Thank you, your
--     cheese pizza has been ordered.\".
--
-- Not all Amazon Lex messages require a user response. For example, a
-- conclusion statement does not require a response. Some messages require
-- only a \"yes\" or \"no\" user response. In addition to the @message@,
-- Amazon Lex provides additional context about the message in the response
-- that you might use to enhance client behavior, for example, to display
-- the appropriate client user interface. These are the @slotToElicit@,
-- @dialogState@, @intentName@, and @slots@ fields in the response.
-- Consider the following examples:
--
-- -   If the message is to elicit slot data, Amazon Lex returns the
--     following context information:
--
--     -   @dialogState@ set to ElicitSlot
--
--     -   @intentName@ set to the intent name in the current context
--
--     -   @slotToElicit@ set to the slot name for which the @message@ is
--         eliciting information
--
--     -   @slots@ set to a map of slots, configured for the intent, with
--         currently known values
--
-- -   If the message is a confirmation prompt, the @dialogState@ is set to
--     ConfirmIntent and @SlotToElicit@ is set to null.
--
-- -   If the message is a clarification prompt (configured for the intent)
--     that indicates that user intent is not understood, the @dialogState@
--     is set to ElicitIntent and @slotToElicit@ is set to null.
--
-- In addition, Amazon Lex also returns your application-specific
-- @sessionAttributes@. For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html Managing Conversation Context>.
module Amazonka.LexRuntime.PostText
  ( -- * Creating a Request
    PostText (..),
    newPostText,

    -- * Request Lenses
    postText_activeContexts,
    postText_requestAttributes,
    postText_sessionAttributes,
    postText_botName,
    postText_botAlias,
    postText_userId,
    postText_inputText,

    -- * Destructuring the Response
    PostTextResponse (..),
    newPostTextResponse,

    -- * Response Lenses
    postTextResponse_sentimentResponse,
    postTextResponse_nluIntentConfidence,
    postTextResponse_slots,
    postTextResponse_responseCard,
    postTextResponse_intentName,
    postTextResponse_botVersion,
    postTextResponse_dialogState,
    postTextResponse_activeContexts,
    postTextResponse_alternativeIntents,
    postTextResponse_messageFormat,
    postTextResponse_message,
    postTextResponse_sessionId,
    postTextResponse_slotToElicit,
    postTextResponse_sessionAttributes,
    postTextResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.LexRuntime.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newPostText' smart constructor.
data PostText = PostText'
  { -- | A list of contexts active for the request. A context can be activated
    -- when a previous intent is fulfilled, or by including the context in the
    -- request,
    --
    -- If you don\'t specify a list of contexts, Amazon Lex will use the
    -- current list of contexts for the session. If you specify an empty list,
    -- all contexts for the session are cleared.
    PostText -> Maybe (Sensitive [ActiveContext])
activeContexts :: Prelude.Maybe (Core.Sensitive [ActiveContext]),
    -- | Request-specific information passed between Amazon Lex and a client
    -- application.
    --
    -- The namespace @x-amz-lex:@ is reserved for special attributes. Don\'t
    -- create any request attributes with the prefix @x-amz-lex:@.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs Setting Request Attributes>.
    PostText -> Maybe (Sensitive (HashMap Text Text))
requestAttributes :: Prelude.Maybe (Core.Sensitive (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | Application-specific information passed between Amazon Lex and a client
    -- application.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs Setting Session Attributes>.
    PostText -> Maybe (Sensitive (HashMap Text Text))
sessionAttributes :: Prelude.Maybe (Core.Sensitive (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | The name of the Amazon Lex bot.
    PostText -> Text
botName :: Prelude.Text,
    -- | The alias of the Amazon Lex bot.
    PostText -> Text
botAlias :: Prelude.Text,
    -- | The ID of the client application user. Amazon Lex uses this to identify
    -- a user\'s conversation with your bot. At runtime, each request must
    -- contain the @userID@ field.
    --
    -- To decide the user ID to use for your application, consider the
    -- following factors.
    --
    -- -   The @userID@ field must not contain any personally identifiable
    --     information of the user, for example, name, personal identification
    --     numbers, or other end user personal information.
    --
    -- -   If you want a user to start a conversation on one device and
    --     continue on another device, use a user-specific identifier.
    --
    -- -   If you want the same user to be able to have two independent
    --     conversations on two different devices, choose a device-specific
    --     identifier.
    --
    -- -   A user can\'t have two independent conversations with two different
    --     versions of the same bot. For example, a user can\'t have a
    --     conversation with the PROD and BETA versions of the same bot. If you
    --     anticipate that a user will need to have conversation with two
    --     different versions, for example, while testing, include the bot
    --     alias in the user ID to separate the two conversations.
    PostText -> Text
userId :: Prelude.Text,
    -- | The text that the user entered (Amazon Lex interprets this text).
    PostText -> Sensitive Text
inputText :: Core.Sensitive Prelude.Text
  }
  deriving (PostText -> PostText -> Bool
(PostText -> PostText -> Bool)
-> (PostText -> PostText -> Bool) -> Eq PostText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PostText -> PostText -> Bool
$c/= :: PostText -> PostText -> Bool
== :: PostText -> PostText -> Bool
$c== :: PostText -> PostText -> Bool
Prelude.Eq, Int -> PostText -> ShowS
[PostText] -> ShowS
PostText -> String
(Int -> PostText -> ShowS)
-> (PostText -> String) -> ([PostText] -> ShowS) -> Show PostText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PostText] -> ShowS
$cshowList :: [PostText] -> ShowS
show :: PostText -> String
$cshow :: PostText -> String
showsPrec :: Int -> PostText -> ShowS
$cshowsPrec :: Int -> PostText -> ShowS
Prelude.Show, (forall x. PostText -> Rep PostText x)
-> (forall x. Rep PostText x -> PostText) -> Generic PostText
forall x. Rep PostText x -> PostText
forall x. PostText -> Rep PostText x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PostText x -> PostText
$cfrom :: forall x. PostText -> Rep PostText x
Prelude.Generic)

-- |
-- Create a value of 'PostText' 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:
--
-- 'activeContexts', 'postText_activeContexts' - A list of contexts active for the request. A context can be activated
-- when a previous intent is fulfilled, or by including the context in the
-- request,
--
-- If you don\'t specify a list of contexts, Amazon Lex will use the
-- current list of contexts for the session. If you specify an empty list,
-- all contexts for the session are cleared.
--
-- 'requestAttributes', 'postText_requestAttributes' - Request-specific information passed between Amazon Lex and a client
-- application.
--
-- The namespace @x-amz-lex:@ is reserved for special attributes. Don\'t
-- create any request attributes with the prefix @x-amz-lex:@.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs Setting Request Attributes>.
--
-- 'sessionAttributes', 'postText_sessionAttributes' - Application-specific information passed between Amazon Lex and a client
-- application.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs Setting Session Attributes>.
--
-- 'botName', 'postText_botName' - The name of the Amazon Lex bot.
--
-- 'botAlias', 'postText_botAlias' - The alias of the Amazon Lex bot.
--
-- 'userId', 'postText_userId' - The ID of the client application user. Amazon Lex uses this to identify
-- a user\'s conversation with your bot. At runtime, each request must
-- contain the @userID@ field.
--
-- To decide the user ID to use for your application, consider the
-- following factors.
--
-- -   The @userID@ field must not contain any personally identifiable
--     information of the user, for example, name, personal identification
--     numbers, or other end user personal information.
--
-- -   If you want a user to start a conversation on one device and
--     continue on another device, use a user-specific identifier.
--
-- -   If you want the same user to be able to have two independent
--     conversations on two different devices, choose a device-specific
--     identifier.
--
-- -   A user can\'t have two independent conversations with two different
--     versions of the same bot. For example, a user can\'t have a
--     conversation with the PROD and BETA versions of the same bot. If you
--     anticipate that a user will need to have conversation with two
--     different versions, for example, while testing, include the bot
--     alias in the user ID to separate the two conversations.
--
-- 'inputText', 'postText_inputText' - The text that the user entered (Amazon Lex interprets this text).
newPostText ::
  -- | 'botName'
  Prelude.Text ->
  -- | 'botAlias'
  Prelude.Text ->
  -- | 'userId'
  Prelude.Text ->
  -- | 'inputText'
  Prelude.Text ->
  PostText
newPostText :: Text -> Text -> Text -> Text -> PostText
newPostText Text
pBotName_ Text
pBotAlias_ Text
pUserId_ Text
pInputText_ =
  PostText' :: Maybe (Sensitive [ActiveContext])
-> Maybe (Sensitive (HashMap Text Text))
-> Maybe (Sensitive (HashMap Text Text))
-> Text
-> Text
-> Text
-> Sensitive Text
-> PostText
PostText'
    { $sel:activeContexts:PostText' :: Maybe (Sensitive [ActiveContext])
activeContexts = Maybe (Sensitive [ActiveContext])
forall a. Maybe a
Prelude.Nothing,
      $sel:requestAttributes:PostText' :: Maybe (Sensitive (HashMap Text Text))
requestAttributes = Maybe (Sensitive (HashMap Text Text))
forall a. Maybe a
Prelude.Nothing,
      $sel:sessionAttributes:PostText' :: Maybe (Sensitive (HashMap Text Text))
sessionAttributes = Maybe (Sensitive (HashMap Text Text))
forall a. Maybe a
Prelude.Nothing,
      $sel:botName:PostText' :: Text
botName = Text
pBotName_,
      $sel:botAlias:PostText' :: Text
botAlias = Text
pBotAlias_,
      $sel:userId:PostText' :: Text
userId = Text
pUserId_,
      $sel:inputText:PostText' :: Sensitive Text
inputText = Tagged Text (Identity Text)
-> Tagged (Sensitive Text) (Identity (Sensitive Text))
forall a. Iso' (Sensitive a) a
Core._Sensitive (Tagged Text (Identity Text)
 -> Tagged (Sensitive Text) (Identity (Sensitive Text)))
-> Text -> Sensitive Text
forall t b. AReview t b -> b -> t
Lens.# Text
pInputText_
    }

-- | A list of contexts active for the request. A context can be activated
-- when a previous intent is fulfilled, or by including the context in the
-- request,
--
-- If you don\'t specify a list of contexts, Amazon Lex will use the
-- current list of contexts for the session. If you specify an empty list,
-- all contexts for the session are cleared.
postText_activeContexts :: Lens.Lens' PostText (Prelude.Maybe [ActiveContext])
postText_activeContexts :: (Maybe [ActiveContext] -> f (Maybe [ActiveContext]))
-> PostText -> f PostText
postText_activeContexts = (PostText -> Maybe (Sensitive [ActiveContext]))
-> (PostText -> Maybe (Sensitive [ActiveContext]) -> PostText)
-> Lens
     PostText
     PostText
     (Maybe (Sensitive [ActiveContext]))
     (Maybe (Sensitive [ActiveContext]))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Maybe (Sensitive [ActiveContext])
activeContexts :: Maybe (Sensitive [ActiveContext])
$sel:activeContexts:PostText' :: PostText -> Maybe (Sensitive [ActiveContext])
activeContexts} -> Maybe (Sensitive [ActiveContext])
activeContexts) (\s :: PostText
s@PostText' {} Maybe (Sensitive [ActiveContext])
a -> PostText
s {$sel:activeContexts:PostText' :: Maybe (Sensitive [ActiveContext])
activeContexts = Maybe (Sensitive [ActiveContext])
a} :: PostText) ((Maybe (Sensitive [ActiveContext])
  -> f (Maybe (Sensitive [ActiveContext])))
 -> PostText -> f PostText)
-> ((Maybe [ActiveContext] -> f (Maybe [ActiveContext]))
    -> Maybe (Sensitive [ActiveContext])
    -> f (Maybe (Sensitive [ActiveContext])))
-> (Maybe [ActiveContext] -> f (Maybe [ActiveContext]))
-> PostText
-> f PostText
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (Sensitive [ActiveContext])
  (Sensitive [ActiveContext])
  [ActiveContext]
  [ActiveContext]
-> Iso
     (Maybe (Sensitive [ActiveContext]))
     (Maybe (Sensitive [ActiveContext]))
     (Maybe [ActiveContext])
     (Maybe [ActiveContext])
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 (AnIso
  (Sensitive [ActiveContext])
  (Sensitive [ActiveContext])
  [ActiveContext]
  [ActiveContext]
forall a. Iso' (Sensitive a) a
Core._Sensitive AnIso
  (Sensitive [ActiveContext])
  (Sensitive [ActiveContext])
  [ActiveContext]
  [ActiveContext]
-> (Exchange
      [ActiveContext]
      [ActiveContext]
      [ActiveContext]
      (Identity [ActiveContext])
    -> Exchange
         [ActiveContext]
         [ActiveContext]
         [ActiveContext]
         (Identity [ActiveContext]))
-> AnIso
     (Sensitive [ActiveContext])
     (Sensitive [ActiveContext])
     [ActiveContext]
     [ActiveContext]
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Exchange
  [ActiveContext]
  [ActiveContext]
  [ActiveContext]
  (Identity [ActiveContext])
-> Exchange
     [ActiveContext]
     [ActiveContext]
     [ActiveContext]
     (Identity [ActiveContext])
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | Request-specific information passed between Amazon Lex and a client
-- application.
--
-- The namespace @x-amz-lex:@ is reserved for special attributes. Don\'t
-- create any request attributes with the prefix @x-amz-lex:@.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs Setting Request Attributes>.
postText_requestAttributes :: Lens.Lens' PostText (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
postText_requestAttributes :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostText -> f PostText
postText_requestAttributes = (PostText -> Maybe (Sensitive (HashMap Text Text)))
-> (PostText -> Maybe (Sensitive (HashMap Text Text)) -> PostText)
-> Lens
     PostText
     PostText
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Maybe (Sensitive (HashMap Text Text))
requestAttributes :: Maybe (Sensitive (HashMap Text Text))
$sel:requestAttributes:PostText' :: PostText -> Maybe (Sensitive (HashMap Text Text))
requestAttributes} -> Maybe (Sensitive (HashMap Text Text))
requestAttributes) (\s :: PostText
s@PostText' {} Maybe (Sensitive (HashMap Text Text))
a -> PostText
s {$sel:requestAttributes:PostText' :: Maybe (Sensitive (HashMap Text Text))
requestAttributes = Maybe (Sensitive (HashMap Text Text))
a} :: PostText) ((Maybe (Sensitive (HashMap Text Text))
  -> f (Maybe (Sensitive (HashMap Text Text))))
 -> PostText -> f PostText)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (Sensitive (HashMap Text Text))
    -> f (Maybe (Sensitive (HashMap Text Text))))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostText
-> f PostText
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 (AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
forall a. Iso' (Sensitive a) a
Core._Sensitive AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> (Exchange
      (HashMap Text Text)
      (HashMap Text Text)
      (HashMap Text Text)
      (Identity (HashMap Text Text))
    -> Exchange
         (HashMap Text Text)
         (HashMap Text Text)
         (HashMap Text Text)
         (Identity (HashMap Text Text)))
-> AnIso
     (Sensitive (HashMap Text Text))
     (Sensitive (HashMap Text Text))
     (HashMap Text Text)
     (HashMap Text Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Exchange
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (Identity (HashMap Text Text))
-> Exchange
     (HashMap Text Text)
     (HashMap Text Text)
     (HashMap Text Text)
     (Identity (HashMap Text Text))
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | Application-specific information passed between Amazon Lex and a client
-- application.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs Setting Session Attributes>.
postText_sessionAttributes :: Lens.Lens' PostText (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
postText_sessionAttributes :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostText -> f PostText
postText_sessionAttributes = (PostText -> Maybe (Sensitive (HashMap Text Text)))
-> (PostText -> Maybe (Sensitive (HashMap Text Text)) -> PostText)
-> Lens
     PostText
     PostText
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Maybe (Sensitive (HashMap Text Text))
sessionAttributes :: Maybe (Sensitive (HashMap Text Text))
$sel:sessionAttributes:PostText' :: PostText -> Maybe (Sensitive (HashMap Text Text))
sessionAttributes} -> Maybe (Sensitive (HashMap Text Text))
sessionAttributes) (\s :: PostText
s@PostText' {} Maybe (Sensitive (HashMap Text Text))
a -> PostText
s {$sel:sessionAttributes:PostText' :: Maybe (Sensitive (HashMap Text Text))
sessionAttributes = Maybe (Sensitive (HashMap Text Text))
a} :: PostText) ((Maybe (Sensitive (HashMap Text Text))
  -> f (Maybe (Sensitive (HashMap Text Text))))
 -> PostText -> f PostText)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (Sensitive (HashMap Text Text))
    -> f (Maybe (Sensitive (HashMap Text Text))))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostText
-> f PostText
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 (AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
forall a. Iso' (Sensitive a) a
Core._Sensitive AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> (Exchange
      (HashMap Text Text)
      (HashMap Text Text)
      (HashMap Text Text)
      (Identity (HashMap Text Text))
    -> Exchange
         (HashMap Text Text)
         (HashMap Text Text)
         (HashMap Text Text)
         (Identity (HashMap Text Text)))
-> AnIso
     (Sensitive (HashMap Text Text))
     (Sensitive (HashMap Text Text))
     (HashMap Text Text)
     (HashMap Text Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Exchange
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (Identity (HashMap Text Text))
-> Exchange
     (HashMap Text Text)
     (HashMap Text Text)
     (HashMap Text Text)
     (Identity (HashMap Text Text))
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | The name of the Amazon Lex bot.
postText_botName :: Lens.Lens' PostText Prelude.Text
postText_botName :: (Text -> f Text) -> PostText -> f PostText
postText_botName = (PostText -> Text)
-> (PostText -> Text -> PostText)
-> Lens PostText PostText Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Text
botName :: Text
$sel:botName:PostText' :: PostText -> Text
botName} -> Text
botName) (\s :: PostText
s@PostText' {} Text
a -> PostText
s {$sel:botName:PostText' :: Text
botName = Text
a} :: PostText)

-- | The alias of the Amazon Lex bot.
postText_botAlias :: Lens.Lens' PostText Prelude.Text
postText_botAlias :: (Text -> f Text) -> PostText -> f PostText
postText_botAlias = (PostText -> Text)
-> (PostText -> Text -> PostText)
-> Lens PostText PostText Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Text
botAlias :: Text
$sel:botAlias:PostText' :: PostText -> Text
botAlias} -> Text
botAlias) (\s :: PostText
s@PostText' {} Text
a -> PostText
s {$sel:botAlias:PostText' :: Text
botAlias = Text
a} :: PostText)

-- | The ID of the client application user. Amazon Lex uses this to identify
-- a user\'s conversation with your bot. At runtime, each request must
-- contain the @userID@ field.
--
-- To decide the user ID to use for your application, consider the
-- following factors.
--
-- -   The @userID@ field must not contain any personally identifiable
--     information of the user, for example, name, personal identification
--     numbers, or other end user personal information.
--
-- -   If you want a user to start a conversation on one device and
--     continue on another device, use a user-specific identifier.
--
-- -   If you want the same user to be able to have two independent
--     conversations on two different devices, choose a device-specific
--     identifier.
--
-- -   A user can\'t have two independent conversations with two different
--     versions of the same bot. For example, a user can\'t have a
--     conversation with the PROD and BETA versions of the same bot. If you
--     anticipate that a user will need to have conversation with two
--     different versions, for example, while testing, include the bot
--     alias in the user ID to separate the two conversations.
postText_userId :: Lens.Lens' PostText Prelude.Text
postText_userId :: (Text -> f Text) -> PostText -> f PostText
postText_userId = (PostText -> Text)
-> (PostText -> Text -> PostText)
-> Lens PostText PostText Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Text
userId :: Text
$sel:userId:PostText' :: PostText -> Text
userId} -> Text
userId) (\s :: PostText
s@PostText' {} Text
a -> PostText
s {$sel:userId:PostText' :: Text
userId = Text
a} :: PostText)

-- | The text that the user entered (Amazon Lex interprets this text).
postText_inputText :: Lens.Lens' PostText Prelude.Text
postText_inputText :: (Text -> f Text) -> PostText -> f PostText
postText_inputText = (PostText -> Sensitive Text)
-> (PostText -> Sensitive Text -> PostText)
-> Lens PostText PostText (Sensitive Text) (Sensitive Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostText' {Sensitive Text
inputText :: Sensitive Text
$sel:inputText:PostText' :: PostText -> Sensitive Text
inputText} -> Sensitive Text
inputText) (\s :: PostText
s@PostText' {} Sensitive Text
a -> PostText
s {$sel:inputText:PostText' :: Sensitive Text
inputText = Sensitive Text
a} :: PostText) ((Sensitive Text -> f (Sensitive Text)) -> PostText -> f PostText)
-> ((Text -> f Text) -> Sensitive Text -> f (Sensitive Text))
-> (Text -> f Text)
-> PostText
-> f PostText
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (Text -> f Text) -> Sensitive Text -> f (Sensitive Text)
forall a. Iso' (Sensitive a) a
Core._Sensitive

instance Core.AWSRequest PostText where
  type AWSResponse PostText = PostTextResponse
  request :: PostText -> Request PostText
request = Service -> PostText -> Request PostText
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy PostText
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse PostText)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse PostText))
-> Logger
-> Service
-> Proxy PostText
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse PostText)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe SentimentResponse
-> Maybe IntentConfidence
-> Maybe (Sensitive (HashMap Text Text))
-> Maybe ResponseCard
-> Maybe Text
-> Maybe Text
-> Maybe DialogState
-> Maybe (Sensitive [ActiveContext])
-> Maybe [PredictedIntent]
-> Maybe MessageFormatType
-> Maybe (Sensitive Text)
-> Maybe Text
-> Maybe Text
-> Maybe (Sensitive (HashMap Text Text))
-> Int
-> PostTextResponse
PostTextResponse'
            (Maybe SentimentResponse
 -> Maybe IntentConfidence
 -> Maybe (Sensitive (HashMap Text Text))
 -> Maybe ResponseCard
 -> Maybe Text
 -> Maybe Text
 -> Maybe DialogState
 -> Maybe (Sensitive [ActiveContext])
 -> Maybe [PredictedIntent]
 -> Maybe MessageFormatType
 -> Maybe (Sensitive Text)
 -> Maybe Text
 -> Maybe Text
 -> Maybe (Sensitive (HashMap Text Text))
 -> Int
 -> PostTextResponse)
-> Either String (Maybe SentimentResponse)
-> Either
     String
     (Maybe IntentConfidence
      -> Maybe (Sensitive (HashMap Text Text))
      -> Maybe ResponseCard
      -> Maybe Text
      -> Maybe Text
      -> Maybe DialogState
      -> Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe SentimentResponse)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"sentimentResponse")
            Either
  String
  (Maybe IntentConfidence
   -> Maybe (Sensitive (HashMap Text Text))
   -> Maybe ResponseCard
   -> Maybe Text
   -> Maybe Text
   -> Maybe DialogState
   -> Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe IntentConfidence)
-> Either
     String
     (Maybe (Sensitive (HashMap Text Text))
      -> Maybe ResponseCard
      -> Maybe Text
      -> Maybe Text
      -> Maybe DialogState
      -> Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe IntentConfidence)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"nluIntentConfidence")
            Either
  String
  (Maybe (Sensitive (HashMap Text Text))
   -> Maybe ResponseCard
   -> Maybe Text
   -> Maybe Text
   -> Maybe DialogState
   -> Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe (Sensitive (HashMap Text Text)))
-> Either
     String
     (Maybe ResponseCard
      -> Maybe Text
      -> Maybe Text
      -> Maybe DialogState
      -> Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object
-> Text
-> Either String (Maybe (Maybe (Sensitive (HashMap Text Text))))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"slots" Either String (Maybe (Maybe (Sensitive (HashMap Text Text))))
-> Maybe (Sensitive (HashMap Text Text))
-> Either String (Maybe (Sensitive (HashMap Text Text)))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (Sensitive (HashMap Text Text))
forall a. Monoid a => a
Prelude.mempty)
            Either
  String
  (Maybe ResponseCard
   -> Maybe Text
   -> Maybe Text
   -> Maybe DialogState
   -> Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe ResponseCard)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe DialogState
      -> Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe ResponseCard)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"responseCard")
            Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe DialogState
   -> Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe DialogState
      -> Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"intentName")
            Either
  String
  (Maybe Text
   -> Maybe DialogState
   -> Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe DialogState
      -> Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"botVersion")
            Either
  String
  (Maybe DialogState
   -> Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe DialogState)
-> Either
     String
     (Maybe (Sensitive [ActiveContext])
      -> Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe DialogState)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"dialogState")
            Either
  String
  (Maybe (Sensitive [ActiveContext])
   -> Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe (Sensitive [ActiveContext]))
-> Either
     String
     (Maybe [PredictedIntent]
      -> Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object
-> Text
-> Either String (Maybe (Maybe (Sensitive [ActiveContext])))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"activeContexts" Either String (Maybe (Maybe (Sensitive [ActiveContext])))
-> Maybe (Sensitive [ActiveContext])
-> Either String (Maybe (Sensitive [ActiveContext]))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (Sensitive [ActiveContext])
forall a. Monoid a => a
Prelude.mempty)
            Either
  String
  (Maybe [PredictedIntent]
   -> Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe [PredictedIntent])
-> Either
     String
     (Maybe MessageFormatType
      -> Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Either String (Maybe (Maybe [PredictedIntent]))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"alternativeIntents"
                            Either String (Maybe (Maybe [PredictedIntent]))
-> Maybe [PredictedIntent]
-> Either String (Maybe [PredictedIntent])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [PredictedIntent]
forall a. Monoid a => a
Prelude.mempty
                        )
            Either
  String
  (Maybe MessageFormatType
   -> Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe MessageFormatType)
-> Either
     String
     (Maybe (Sensitive Text)
      -> Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe MessageFormatType)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"messageFormat")
            Either
  String
  (Maybe (Sensitive Text)
   -> Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe (Sensitive Text))
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe (Sensitive Text))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"message")
            Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe (Sensitive (HashMap Text Text))
      -> Int
      -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"sessionId")
            Either
  String
  (Maybe Text
   -> Maybe (Sensitive (HashMap Text Text))
   -> Int
   -> PostTextResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe (Sensitive (HashMap Text Text)) -> Int -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"slotToElicit")
            Either
  String
  (Maybe (Sensitive (HashMap Text Text)) -> Int -> PostTextResponse)
-> Either String (Maybe (Sensitive (HashMap Text Text)))
-> Either String (Int -> PostTextResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object
-> Text
-> Either String (Maybe (Maybe (Sensitive (HashMap Text Text))))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"sessionAttributes"
                            Either String (Maybe (Maybe (Sensitive (HashMap Text Text))))
-> Maybe (Sensitive (HashMap Text Text))
-> Either String (Maybe (Sensitive (HashMap Text Text)))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (Sensitive (HashMap Text Text))
forall a. Monoid a => a
Prelude.mempty
                        )
            Either String (Int -> PostTextResponse)
-> Either String Int -> Either String PostTextResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable PostText

instance Prelude.NFData PostText

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

instance Core.ToJSON PostText where
  toJSON :: PostText -> Value
toJSON PostText' {Maybe (Sensitive [ActiveContext])
Maybe (Sensitive (HashMap Text Text))
Text
Sensitive Text
inputText :: Sensitive Text
userId :: Text
botAlias :: Text
botName :: Text
sessionAttributes :: Maybe (Sensitive (HashMap Text Text))
requestAttributes :: Maybe (Sensitive (HashMap Text Text))
activeContexts :: Maybe (Sensitive [ActiveContext])
$sel:inputText:PostText' :: PostText -> Sensitive Text
$sel:userId:PostText' :: PostText -> Text
$sel:botAlias:PostText' :: PostText -> Text
$sel:botName:PostText' :: PostText -> Text
$sel:sessionAttributes:PostText' :: PostText -> Maybe (Sensitive (HashMap Text Text))
$sel:requestAttributes:PostText' :: PostText -> Maybe (Sensitive (HashMap Text Text))
$sel:activeContexts:PostText' :: PostText -> Maybe (Sensitive [ActiveContext])
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"activeContexts" Text -> Sensitive [ActiveContext] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Sensitive [ActiveContext] -> Pair)
-> Maybe (Sensitive [ActiveContext]) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (Sensitive [ActiveContext])
activeContexts,
            (Text
"requestAttributes" Text -> Sensitive (HashMap Text Text) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Sensitive (HashMap Text Text) -> Pair)
-> Maybe (Sensitive (HashMap Text Text)) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (Sensitive (HashMap Text Text))
requestAttributes,
            (Text
"sessionAttributes" Text -> Sensitive (HashMap Text Text) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Sensitive (HashMap Text Text) -> Pair)
-> Maybe (Sensitive (HashMap Text Text)) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (Sensitive (HashMap Text Text))
sessionAttributes,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"inputText" Text -> Sensitive Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Sensitive Text
inputText)
          ]
      )

instance Core.ToPath PostText where
  toPath :: PostText -> ByteString
toPath PostText' {Maybe (Sensitive [ActiveContext])
Maybe (Sensitive (HashMap Text Text))
Text
Sensitive Text
inputText :: Sensitive Text
userId :: Text
botAlias :: Text
botName :: Text
sessionAttributes :: Maybe (Sensitive (HashMap Text Text))
requestAttributes :: Maybe (Sensitive (HashMap Text Text))
activeContexts :: Maybe (Sensitive [ActiveContext])
$sel:inputText:PostText' :: PostText -> Sensitive Text
$sel:userId:PostText' :: PostText -> Text
$sel:botAlias:PostText' :: PostText -> Text
$sel:botName:PostText' :: PostText -> Text
$sel:sessionAttributes:PostText' :: PostText -> Maybe (Sensitive (HashMap Text Text))
$sel:requestAttributes:PostText' :: PostText -> Maybe (Sensitive (HashMap Text Text))
$sel:activeContexts:PostText' :: PostText -> Maybe (Sensitive [ActiveContext])
..} =
    [ByteString] -> ByteString
forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/bot/",
        Text -> ByteString
forall a. ToByteString a => a -> ByteString
Core.toBS Text
botName,
        ByteString
"/alias/",
        Text -> ByteString
forall a. ToByteString a => a -> ByteString
Core.toBS Text
botAlias,
        ByteString
"/user/",
        Text -> ByteString
forall a. ToByteString a => a -> ByteString
Core.toBS Text
userId,
        ByteString
"/text"
      ]

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

-- | /See:/ 'newPostTextResponse' smart constructor.
data PostTextResponse = PostTextResponse'
  { -- | The sentiment expressed in and utterance.
    --
    -- When the bot is configured to send utterances to Amazon Comprehend for
    -- sentiment analysis, this field contains the result of the analysis.
    PostTextResponse -> Maybe SentimentResponse
sentimentResponse :: Prelude.Maybe SentimentResponse,
    -- | Provides a score that indicates how confident Amazon Lex is that the
    -- returned intent is the one that matches the user\'s intent. The score is
    -- between 0.0 and 1.0. For more information, see
    -- <https://docs.aws.amazon.com/lex/latest/dg/confidence-scores.html Confidence Scores>.
    --
    -- The score is a relative score, not an absolute score. The score may
    -- change based on improvements to Amazon Lex.
    PostTextResponse -> Maybe IntentConfidence
nluIntentConfidence :: Prelude.Maybe IntentConfidence,
    -- | The intent slots that Amazon Lex detected from the user input in the
    -- conversation.
    --
    -- Amazon Lex creates a resolution list containing likely values for a
    -- slot. The value that it returns is determined by the
    -- @valueSelectionStrategy@ selected when the slot type was created or
    -- updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@, the
    -- value provided by the user is returned, if the user value is similar to
    -- the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@
    -- Amazon Lex returns the first value in the resolution list or, if there
    -- is no resolution list, null. If you don\'t specify a
    -- @valueSelectionStrategy@, the default is @ORIGINAL_VALUE@.
    PostTextResponse -> Maybe (Sensitive (HashMap Text Text))
slots :: Prelude.Maybe (Core.Sensitive (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | Represents the options that the user has to respond to the current
    -- prompt. Response Card can come from the bot configuration (in the Amazon
    -- Lex console, choose the settings button next to a slot) or from a code
    -- hook (Lambda function).
    PostTextResponse -> Maybe ResponseCard
responseCard :: Prelude.Maybe ResponseCard,
    -- | The current user intent that Amazon Lex is aware of.
    PostTextResponse -> Maybe Text
intentName :: Prelude.Maybe Prelude.Text,
    -- | The version of the bot that responded to the conversation. You can use
    -- this information to help determine if one version of a bot is performing
    -- better than another version.
    PostTextResponse -> Maybe Text
botVersion :: Prelude.Maybe Prelude.Text,
    -- | Identifies the current state of the user interaction. Amazon Lex returns
    -- one of the following values as @dialogState@. The client can optionally
    -- use this information to customize the user interface.
    --
    -- -   @ElicitIntent@ - Amazon Lex wants to elicit user intent.
    --
    --     For example, a user might utter an intent (\"I want to order a
    --     pizza\"). If Amazon Lex cannot infer the user intent from this
    --     utterance, it will return this dialogState.
    --
    -- -   @ConfirmIntent@ - Amazon Lex is expecting a \"yes\" or \"no\"
    --     response.
    --
    --     For example, Amazon Lex wants user confirmation before fulfilling an
    --     intent.
    --
    --     Instead of a simple \"yes\" or \"no,\" a user might respond with
    --     additional information. For example, \"yes, but make it thick crust
    --     pizza\" or \"no, I want to order a drink\". Amazon Lex can process
    --     such additional information (in these examples, update the crust
    --     type slot value, or change intent from OrderPizza to OrderDrink).
    --
    -- -   @ElicitSlot@ - Amazon Lex is expecting a slot value for the current
    --     intent.
    --
    --     For example, suppose that in the response Amazon Lex sends this
    --     message: \"What size pizza would you like?\". A user might reply
    --     with the slot value (e.g., \"medium\"). The user might also provide
    --     additional information in the response (e.g., \"medium thick crust
    --     pizza\"). Amazon Lex can process such additional information
    --     appropriately.
    --
    -- -   @Fulfilled@ - Conveys that the Lambda function configured for the
    --     intent has successfully fulfilled the intent.
    --
    -- -   @ReadyForFulfillment@ - Conveys that the client has to fulfill the
    --     intent.
    --
    -- -   @Failed@ - Conveys that the conversation with the user failed.
    --
    --     This can happen for various reasons including that the user did not
    --     provide an appropriate response to prompts from the service (you can
    --     configure how many times Amazon Lex can prompt a user for specific
    --     information), or the Lambda function failed to fulfill the intent.
    PostTextResponse -> Maybe DialogState
dialogState :: Prelude.Maybe DialogState,
    -- | A list of active contexts for the session. A context can be set when an
    -- intent is fulfilled or by calling the @PostContent@, @PostText@, or
    -- @PutSession@ operation.
    --
    -- You can use a context to control the intents that can follow up an
    -- intent, or to modify the operation of your application.
    PostTextResponse -> Maybe (Sensitive [ActiveContext])
activeContexts :: Prelude.Maybe (Core.Sensitive [ActiveContext]),
    -- | One to four alternative intents that may be applicable to the user\'s
    -- intent.
    --
    -- Each alternative includes a score that indicates how confident Amazon
    -- Lex is that the intent matches the user\'s intent. The intents are
    -- sorted by the confidence score.
    PostTextResponse -> Maybe [PredictedIntent]
alternativeIntents :: Prelude.Maybe [PredictedIntent],
    -- | The format of the response message. One of the following values:
    --
    -- -   @PlainText@ - The message contains plain UTF-8 text.
    --
    -- -   @CustomPayload@ - The message is a custom format defined by the
    --     Lambda function.
    --
    -- -   @SSML@ - The message contains text formatted for voice output.
    --
    -- -   @Composite@ - The message contains an escaped JSON object containing
    --     one or more messages from the groups that messages were assigned to
    --     when the intent was created.
    PostTextResponse -> Maybe MessageFormatType
messageFormat :: Prelude.Maybe MessageFormatType,
    -- | The message to convey to the user. The message can come from the bot\'s
    -- configuration or from a Lambda function.
    --
    -- If the intent is not configured with a Lambda function, or if the Lambda
    -- function returned @Delegate@ as the @dialogAction.type@ its response,
    -- Amazon Lex decides on the next course of action and selects an
    -- appropriate message from the bot\'s configuration based on the current
    -- interaction context. For example, if Amazon Lex isn\'t able to
    -- understand user input, it uses a clarification prompt message.
    --
    -- When you create an intent you can assign messages to groups. When
    -- messages are assigned to groups Amazon Lex returns one message from each
    -- group in the response. The message field is an escaped JSON string
    -- containing the messages. For more information about the structure of the
    -- JSON string returned, see msg-prompts-formats.
    --
    -- If the Lambda function returns a message, Amazon Lex passes it to the
    -- client in its response.
    PostTextResponse -> Maybe (Sensitive Text)
message :: Prelude.Maybe (Core.Sensitive Prelude.Text),
    -- | A unique identifier for the session.
    PostTextResponse -> Maybe Text
sessionId :: Prelude.Maybe Prelude.Text,
    -- | If the @dialogState@ value is @ElicitSlot@, returns the name of the slot
    -- for which Amazon Lex is eliciting a value.
    PostTextResponse -> Maybe Text
slotToElicit :: Prelude.Maybe Prelude.Text,
    -- | A map of key-value pairs representing the session-specific context
    -- information.
    PostTextResponse -> Maybe (Sensitive (HashMap Text Text))
sessionAttributes :: Prelude.Maybe (Core.Sensitive (Prelude.HashMap Prelude.Text Prelude.Text)),
    -- | The response's http status code.
    PostTextResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (PostTextResponse -> PostTextResponse -> Bool
(PostTextResponse -> PostTextResponse -> Bool)
-> (PostTextResponse -> PostTextResponse -> Bool)
-> Eq PostTextResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PostTextResponse -> PostTextResponse -> Bool
$c/= :: PostTextResponse -> PostTextResponse -> Bool
== :: PostTextResponse -> PostTextResponse -> Bool
$c== :: PostTextResponse -> PostTextResponse -> Bool
Prelude.Eq, Int -> PostTextResponse -> ShowS
[PostTextResponse] -> ShowS
PostTextResponse -> String
(Int -> PostTextResponse -> ShowS)
-> (PostTextResponse -> String)
-> ([PostTextResponse] -> ShowS)
-> Show PostTextResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PostTextResponse] -> ShowS
$cshowList :: [PostTextResponse] -> ShowS
show :: PostTextResponse -> String
$cshow :: PostTextResponse -> String
showsPrec :: Int -> PostTextResponse -> ShowS
$cshowsPrec :: Int -> PostTextResponse -> ShowS
Prelude.Show, (forall x. PostTextResponse -> Rep PostTextResponse x)
-> (forall x. Rep PostTextResponse x -> PostTextResponse)
-> Generic PostTextResponse
forall x. Rep PostTextResponse x -> PostTextResponse
forall x. PostTextResponse -> Rep PostTextResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PostTextResponse x -> PostTextResponse
$cfrom :: forall x. PostTextResponse -> Rep PostTextResponse x
Prelude.Generic)

-- |
-- Create a value of 'PostTextResponse' 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:
--
-- 'sentimentResponse', 'postTextResponse_sentimentResponse' - The sentiment expressed in and utterance.
--
-- When the bot is configured to send utterances to Amazon Comprehend for
-- sentiment analysis, this field contains the result of the analysis.
--
-- 'nluIntentConfidence', 'postTextResponse_nluIntentConfidence' - Provides a score that indicates how confident Amazon Lex is that the
-- returned intent is the one that matches the user\'s intent. The score is
-- between 0.0 and 1.0. For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/confidence-scores.html Confidence Scores>.
--
-- The score is a relative score, not an absolute score. The score may
-- change based on improvements to Amazon Lex.
--
-- 'slots', 'postTextResponse_slots' - The intent slots that Amazon Lex detected from the user input in the
-- conversation.
--
-- Amazon Lex creates a resolution list containing likely values for a
-- slot. The value that it returns is determined by the
-- @valueSelectionStrategy@ selected when the slot type was created or
-- updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@, the
-- value provided by the user is returned, if the user value is similar to
-- the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@
-- Amazon Lex returns the first value in the resolution list or, if there
-- is no resolution list, null. If you don\'t specify a
-- @valueSelectionStrategy@, the default is @ORIGINAL_VALUE@.
--
-- 'responseCard', 'postTextResponse_responseCard' - Represents the options that the user has to respond to the current
-- prompt. Response Card can come from the bot configuration (in the Amazon
-- Lex console, choose the settings button next to a slot) or from a code
-- hook (Lambda function).
--
-- 'intentName', 'postTextResponse_intentName' - The current user intent that Amazon Lex is aware of.
--
-- 'botVersion', 'postTextResponse_botVersion' - The version of the bot that responded to the conversation. You can use
-- this information to help determine if one version of a bot is performing
-- better than another version.
--
-- 'dialogState', 'postTextResponse_dialogState' - Identifies the current state of the user interaction. Amazon Lex returns
-- one of the following values as @dialogState@. The client can optionally
-- use this information to customize the user interface.
--
-- -   @ElicitIntent@ - Amazon Lex wants to elicit user intent.
--
--     For example, a user might utter an intent (\"I want to order a
--     pizza\"). If Amazon Lex cannot infer the user intent from this
--     utterance, it will return this dialogState.
--
-- -   @ConfirmIntent@ - Amazon Lex is expecting a \"yes\" or \"no\"
--     response.
--
--     For example, Amazon Lex wants user confirmation before fulfilling an
--     intent.
--
--     Instead of a simple \"yes\" or \"no,\" a user might respond with
--     additional information. For example, \"yes, but make it thick crust
--     pizza\" or \"no, I want to order a drink\". Amazon Lex can process
--     such additional information (in these examples, update the crust
--     type slot value, or change intent from OrderPizza to OrderDrink).
--
-- -   @ElicitSlot@ - Amazon Lex is expecting a slot value for the current
--     intent.
--
--     For example, suppose that in the response Amazon Lex sends this
--     message: \"What size pizza would you like?\". A user might reply
--     with the slot value (e.g., \"medium\"). The user might also provide
--     additional information in the response (e.g., \"medium thick crust
--     pizza\"). Amazon Lex can process such additional information
--     appropriately.
--
-- -   @Fulfilled@ - Conveys that the Lambda function configured for the
--     intent has successfully fulfilled the intent.
--
-- -   @ReadyForFulfillment@ - Conveys that the client has to fulfill the
--     intent.
--
-- -   @Failed@ - Conveys that the conversation with the user failed.
--
--     This can happen for various reasons including that the user did not
--     provide an appropriate response to prompts from the service (you can
--     configure how many times Amazon Lex can prompt a user for specific
--     information), or the Lambda function failed to fulfill the intent.
--
-- 'activeContexts', 'postTextResponse_activeContexts' - A list of active contexts for the session. A context can be set when an
-- intent is fulfilled or by calling the @PostContent@, @PostText@, or
-- @PutSession@ operation.
--
-- You can use a context to control the intents that can follow up an
-- intent, or to modify the operation of your application.
--
-- 'alternativeIntents', 'postTextResponse_alternativeIntents' - One to four alternative intents that may be applicable to the user\'s
-- intent.
--
-- Each alternative includes a score that indicates how confident Amazon
-- Lex is that the intent matches the user\'s intent. The intents are
-- sorted by the confidence score.
--
-- 'messageFormat', 'postTextResponse_messageFormat' - The format of the response message. One of the following values:
--
-- -   @PlainText@ - The message contains plain UTF-8 text.
--
-- -   @CustomPayload@ - The message is a custom format defined by the
--     Lambda function.
--
-- -   @SSML@ - The message contains text formatted for voice output.
--
-- -   @Composite@ - The message contains an escaped JSON object containing
--     one or more messages from the groups that messages were assigned to
--     when the intent was created.
--
-- 'message', 'postTextResponse_message' - The message to convey to the user. The message can come from the bot\'s
-- configuration or from a Lambda function.
--
-- If the intent is not configured with a Lambda function, or if the Lambda
-- function returned @Delegate@ as the @dialogAction.type@ its response,
-- Amazon Lex decides on the next course of action and selects an
-- appropriate message from the bot\'s configuration based on the current
-- interaction context. For example, if Amazon Lex isn\'t able to
-- understand user input, it uses a clarification prompt message.
--
-- When you create an intent you can assign messages to groups. When
-- messages are assigned to groups Amazon Lex returns one message from each
-- group in the response. The message field is an escaped JSON string
-- containing the messages. For more information about the structure of the
-- JSON string returned, see msg-prompts-formats.
--
-- If the Lambda function returns a message, Amazon Lex passes it to the
-- client in its response.
--
-- 'sessionId', 'postTextResponse_sessionId' - A unique identifier for the session.
--
-- 'slotToElicit', 'postTextResponse_slotToElicit' - If the @dialogState@ value is @ElicitSlot@, returns the name of the slot
-- for which Amazon Lex is eliciting a value.
--
-- 'sessionAttributes', 'postTextResponse_sessionAttributes' - A map of key-value pairs representing the session-specific context
-- information.
--
-- 'httpStatus', 'postTextResponse_httpStatus' - The response's http status code.
newPostTextResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PostTextResponse
newPostTextResponse :: Int -> PostTextResponse
newPostTextResponse Int
pHttpStatus_ =
  PostTextResponse' :: Maybe SentimentResponse
-> Maybe IntentConfidence
-> Maybe (Sensitive (HashMap Text Text))
-> Maybe ResponseCard
-> Maybe Text
-> Maybe Text
-> Maybe DialogState
-> Maybe (Sensitive [ActiveContext])
-> Maybe [PredictedIntent]
-> Maybe MessageFormatType
-> Maybe (Sensitive Text)
-> Maybe Text
-> Maybe Text
-> Maybe (Sensitive (HashMap Text Text))
-> Int
-> PostTextResponse
PostTextResponse'
    { $sel:sentimentResponse:PostTextResponse' :: Maybe SentimentResponse
sentimentResponse =
        Maybe SentimentResponse
forall a. Maybe a
Prelude.Nothing,
      $sel:nluIntentConfidence:PostTextResponse' :: Maybe IntentConfidence
nluIntentConfidence = Maybe IntentConfidence
forall a. Maybe a
Prelude.Nothing,
      $sel:slots:PostTextResponse' :: Maybe (Sensitive (HashMap Text Text))
slots = Maybe (Sensitive (HashMap Text Text))
forall a. Maybe a
Prelude.Nothing,
      $sel:responseCard:PostTextResponse' :: Maybe ResponseCard
responseCard = Maybe ResponseCard
forall a. Maybe a
Prelude.Nothing,
      $sel:intentName:PostTextResponse' :: Maybe Text
intentName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:botVersion:PostTextResponse' :: Maybe Text
botVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:dialogState:PostTextResponse' :: Maybe DialogState
dialogState = Maybe DialogState
forall a. Maybe a
Prelude.Nothing,
      $sel:activeContexts:PostTextResponse' :: Maybe (Sensitive [ActiveContext])
activeContexts = Maybe (Sensitive [ActiveContext])
forall a. Maybe a
Prelude.Nothing,
      $sel:alternativeIntents:PostTextResponse' :: Maybe [PredictedIntent]
alternativeIntents = Maybe [PredictedIntent]
forall a. Maybe a
Prelude.Nothing,
      $sel:messageFormat:PostTextResponse' :: Maybe MessageFormatType
messageFormat = Maybe MessageFormatType
forall a. Maybe a
Prelude.Nothing,
      $sel:message:PostTextResponse' :: Maybe (Sensitive Text)
message = Maybe (Sensitive Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:sessionId:PostTextResponse' :: Maybe Text
sessionId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:slotToElicit:PostTextResponse' :: Maybe Text
slotToElicit = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:sessionAttributes:PostTextResponse' :: Maybe (Sensitive (HashMap Text Text))
sessionAttributes = Maybe (Sensitive (HashMap Text Text))
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:PostTextResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The sentiment expressed in and utterance.
--
-- When the bot is configured to send utterances to Amazon Comprehend for
-- sentiment analysis, this field contains the result of the analysis.
postTextResponse_sentimentResponse :: Lens.Lens' PostTextResponse (Prelude.Maybe SentimentResponse)
postTextResponse_sentimentResponse :: (Maybe SentimentResponse -> f (Maybe SentimentResponse))
-> PostTextResponse -> f PostTextResponse
postTextResponse_sentimentResponse = (PostTextResponse -> Maybe SentimentResponse)
-> (PostTextResponse
    -> Maybe SentimentResponse -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe SentimentResponse)
     (Maybe SentimentResponse)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe SentimentResponse
sentimentResponse :: Maybe SentimentResponse
$sel:sentimentResponse:PostTextResponse' :: PostTextResponse -> Maybe SentimentResponse
sentimentResponse} -> Maybe SentimentResponse
sentimentResponse) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe SentimentResponse
a -> PostTextResponse
s {$sel:sentimentResponse:PostTextResponse' :: Maybe SentimentResponse
sentimentResponse = Maybe SentimentResponse
a} :: PostTextResponse)

-- | Provides a score that indicates how confident Amazon Lex is that the
-- returned intent is the one that matches the user\'s intent. The score is
-- between 0.0 and 1.0. For more information, see
-- <https://docs.aws.amazon.com/lex/latest/dg/confidence-scores.html Confidence Scores>.
--
-- The score is a relative score, not an absolute score. The score may
-- change based on improvements to Amazon Lex.
postTextResponse_nluIntentConfidence :: Lens.Lens' PostTextResponse (Prelude.Maybe IntentConfidence)
postTextResponse_nluIntentConfidence :: (Maybe IntentConfidence -> f (Maybe IntentConfidence))
-> PostTextResponse -> f PostTextResponse
postTextResponse_nluIntentConfidence = (PostTextResponse -> Maybe IntentConfidence)
-> (PostTextResponse -> Maybe IntentConfidence -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe IntentConfidence)
     (Maybe IntentConfidence)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe IntentConfidence
nluIntentConfidence :: Maybe IntentConfidence
$sel:nluIntentConfidence:PostTextResponse' :: PostTextResponse -> Maybe IntentConfidence
nluIntentConfidence} -> Maybe IntentConfidence
nluIntentConfidence) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe IntentConfidence
a -> PostTextResponse
s {$sel:nluIntentConfidence:PostTextResponse' :: Maybe IntentConfidence
nluIntentConfidence = Maybe IntentConfidence
a} :: PostTextResponse)

-- | The intent slots that Amazon Lex detected from the user input in the
-- conversation.
--
-- Amazon Lex creates a resolution list containing likely values for a
-- slot. The value that it returns is determined by the
-- @valueSelectionStrategy@ selected when the slot type was created or
-- updated. If @valueSelectionStrategy@ is set to @ORIGINAL_VALUE@, the
-- value provided by the user is returned, if the user value is similar to
-- the slot values. If @valueSelectionStrategy@ is set to @TOP_RESOLUTION@
-- Amazon Lex returns the first value in the resolution list or, if there
-- is no resolution list, null. If you don\'t specify a
-- @valueSelectionStrategy@, the default is @ORIGINAL_VALUE@.
postTextResponse_slots :: Lens.Lens' PostTextResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
postTextResponse_slots :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostTextResponse -> f PostTextResponse
postTextResponse_slots = (PostTextResponse -> Maybe (Sensitive (HashMap Text Text)))
-> (PostTextResponse
    -> Maybe (Sensitive (HashMap Text Text)) -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe (Sensitive (HashMap Text Text))
slots :: Maybe (Sensitive (HashMap Text Text))
$sel:slots:PostTextResponse' :: PostTextResponse -> Maybe (Sensitive (HashMap Text Text))
slots} -> Maybe (Sensitive (HashMap Text Text))
slots) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe (Sensitive (HashMap Text Text))
a -> PostTextResponse
s {$sel:slots:PostTextResponse' :: Maybe (Sensitive (HashMap Text Text))
slots = Maybe (Sensitive (HashMap Text Text))
a} :: PostTextResponse) ((Maybe (Sensitive (HashMap Text Text))
  -> f (Maybe (Sensitive (HashMap Text Text))))
 -> PostTextResponse -> f PostTextResponse)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (Sensitive (HashMap Text Text))
    -> f (Maybe (Sensitive (HashMap Text Text))))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostTextResponse
-> f PostTextResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 (AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
forall a. Iso' (Sensitive a) a
Core._Sensitive AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> (Exchange
      (HashMap Text Text)
      (HashMap Text Text)
      (HashMap Text Text)
      (Identity (HashMap Text Text))
    -> Exchange
         (HashMap Text Text)
         (HashMap Text Text)
         (HashMap Text Text)
         (Identity (HashMap Text Text)))
-> AnIso
     (Sensitive (HashMap Text Text))
     (Sensitive (HashMap Text Text))
     (HashMap Text Text)
     (HashMap Text Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Exchange
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (Identity (HashMap Text Text))
-> Exchange
     (HashMap Text Text)
     (HashMap Text Text)
     (HashMap Text Text)
     (Identity (HashMap Text Text))
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | Represents the options that the user has to respond to the current
-- prompt. Response Card can come from the bot configuration (in the Amazon
-- Lex console, choose the settings button next to a slot) or from a code
-- hook (Lambda function).
postTextResponse_responseCard :: Lens.Lens' PostTextResponse (Prelude.Maybe ResponseCard)
postTextResponse_responseCard :: (Maybe ResponseCard -> f (Maybe ResponseCard))
-> PostTextResponse -> f PostTextResponse
postTextResponse_responseCard = (PostTextResponse -> Maybe ResponseCard)
-> (PostTextResponse -> Maybe ResponseCard -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe ResponseCard)
     (Maybe ResponseCard)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe ResponseCard
responseCard :: Maybe ResponseCard
$sel:responseCard:PostTextResponse' :: PostTextResponse -> Maybe ResponseCard
responseCard} -> Maybe ResponseCard
responseCard) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe ResponseCard
a -> PostTextResponse
s {$sel:responseCard:PostTextResponse' :: Maybe ResponseCard
responseCard = Maybe ResponseCard
a} :: PostTextResponse)

-- | The current user intent that Amazon Lex is aware of.
postTextResponse_intentName :: Lens.Lens' PostTextResponse (Prelude.Maybe Prelude.Text)
postTextResponse_intentName :: (Maybe Text -> f (Maybe Text))
-> PostTextResponse -> f PostTextResponse
postTextResponse_intentName = (PostTextResponse -> Maybe Text)
-> (PostTextResponse -> Maybe Text -> PostTextResponse)
-> Lens PostTextResponse PostTextResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe Text
intentName :: Maybe Text
$sel:intentName:PostTextResponse' :: PostTextResponse -> Maybe Text
intentName} -> Maybe Text
intentName) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe Text
a -> PostTextResponse
s {$sel:intentName:PostTextResponse' :: Maybe Text
intentName = Maybe Text
a} :: PostTextResponse)

-- | The version of the bot that responded to the conversation. You can use
-- this information to help determine if one version of a bot is performing
-- better than another version.
postTextResponse_botVersion :: Lens.Lens' PostTextResponse (Prelude.Maybe Prelude.Text)
postTextResponse_botVersion :: (Maybe Text -> f (Maybe Text))
-> PostTextResponse -> f PostTextResponse
postTextResponse_botVersion = (PostTextResponse -> Maybe Text)
-> (PostTextResponse -> Maybe Text -> PostTextResponse)
-> Lens PostTextResponse PostTextResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe Text
botVersion :: Maybe Text
$sel:botVersion:PostTextResponse' :: PostTextResponse -> Maybe Text
botVersion} -> Maybe Text
botVersion) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe Text
a -> PostTextResponse
s {$sel:botVersion:PostTextResponse' :: Maybe Text
botVersion = Maybe Text
a} :: PostTextResponse)

-- | Identifies the current state of the user interaction. Amazon Lex returns
-- one of the following values as @dialogState@. The client can optionally
-- use this information to customize the user interface.
--
-- -   @ElicitIntent@ - Amazon Lex wants to elicit user intent.
--
--     For example, a user might utter an intent (\"I want to order a
--     pizza\"). If Amazon Lex cannot infer the user intent from this
--     utterance, it will return this dialogState.
--
-- -   @ConfirmIntent@ - Amazon Lex is expecting a \"yes\" or \"no\"
--     response.
--
--     For example, Amazon Lex wants user confirmation before fulfilling an
--     intent.
--
--     Instead of a simple \"yes\" or \"no,\" a user might respond with
--     additional information. For example, \"yes, but make it thick crust
--     pizza\" or \"no, I want to order a drink\". Amazon Lex can process
--     such additional information (in these examples, update the crust
--     type slot value, or change intent from OrderPizza to OrderDrink).
--
-- -   @ElicitSlot@ - Amazon Lex is expecting a slot value for the current
--     intent.
--
--     For example, suppose that in the response Amazon Lex sends this
--     message: \"What size pizza would you like?\". A user might reply
--     with the slot value (e.g., \"medium\"). The user might also provide
--     additional information in the response (e.g., \"medium thick crust
--     pizza\"). Amazon Lex can process such additional information
--     appropriately.
--
-- -   @Fulfilled@ - Conveys that the Lambda function configured for the
--     intent has successfully fulfilled the intent.
--
-- -   @ReadyForFulfillment@ - Conveys that the client has to fulfill the
--     intent.
--
-- -   @Failed@ - Conveys that the conversation with the user failed.
--
--     This can happen for various reasons including that the user did not
--     provide an appropriate response to prompts from the service (you can
--     configure how many times Amazon Lex can prompt a user for specific
--     information), or the Lambda function failed to fulfill the intent.
postTextResponse_dialogState :: Lens.Lens' PostTextResponse (Prelude.Maybe DialogState)
postTextResponse_dialogState :: (Maybe DialogState -> f (Maybe DialogState))
-> PostTextResponse -> f PostTextResponse
postTextResponse_dialogState = (PostTextResponse -> Maybe DialogState)
-> (PostTextResponse -> Maybe DialogState -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe DialogState)
     (Maybe DialogState)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe DialogState
dialogState :: Maybe DialogState
$sel:dialogState:PostTextResponse' :: PostTextResponse -> Maybe DialogState
dialogState} -> Maybe DialogState
dialogState) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe DialogState
a -> PostTextResponse
s {$sel:dialogState:PostTextResponse' :: Maybe DialogState
dialogState = Maybe DialogState
a} :: PostTextResponse)

-- | A list of active contexts for the session. A context can be set when an
-- intent is fulfilled or by calling the @PostContent@, @PostText@, or
-- @PutSession@ operation.
--
-- You can use a context to control the intents that can follow up an
-- intent, or to modify the operation of your application.
postTextResponse_activeContexts :: Lens.Lens' PostTextResponse (Prelude.Maybe [ActiveContext])
postTextResponse_activeContexts :: (Maybe [ActiveContext] -> f (Maybe [ActiveContext]))
-> PostTextResponse -> f PostTextResponse
postTextResponse_activeContexts = (PostTextResponse -> Maybe (Sensitive [ActiveContext]))
-> (PostTextResponse
    -> Maybe (Sensitive [ActiveContext]) -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe (Sensitive [ActiveContext]))
     (Maybe (Sensitive [ActiveContext]))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe (Sensitive [ActiveContext])
activeContexts :: Maybe (Sensitive [ActiveContext])
$sel:activeContexts:PostTextResponse' :: PostTextResponse -> Maybe (Sensitive [ActiveContext])
activeContexts} -> Maybe (Sensitive [ActiveContext])
activeContexts) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe (Sensitive [ActiveContext])
a -> PostTextResponse
s {$sel:activeContexts:PostTextResponse' :: Maybe (Sensitive [ActiveContext])
activeContexts = Maybe (Sensitive [ActiveContext])
a} :: PostTextResponse) ((Maybe (Sensitive [ActiveContext])
  -> f (Maybe (Sensitive [ActiveContext])))
 -> PostTextResponse -> f PostTextResponse)
-> ((Maybe [ActiveContext] -> f (Maybe [ActiveContext]))
    -> Maybe (Sensitive [ActiveContext])
    -> f (Maybe (Sensitive [ActiveContext])))
-> (Maybe [ActiveContext] -> f (Maybe [ActiveContext]))
-> PostTextResponse
-> f PostTextResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (Sensitive [ActiveContext])
  (Sensitive [ActiveContext])
  [ActiveContext]
  [ActiveContext]
-> Iso
     (Maybe (Sensitive [ActiveContext]))
     (Maybe (Sensitive [ActiveContext]))
     (Maybe [ActiveContext])
     (Maybe [ActiveContext])
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 (AnIso
  (Sensitive [ActiveContext])
  (Sensitive [ActiveContext])
  [ActiveContext]
  [ActiveContext]
forall a. Iso' (Sensitive a) a
Core._Sensitive AnIso
  (Sensitive [ActiveContext])
  (Sensitive [ActiveContext])
  [ActiveContext]
  [ActiveContext]
-> (Exchange
      [ActiveContext]
      [ActiveContext]
      [ActiveContext]
      (Identity [ActiveContext])
    -> Exchange
         [ActiveContext]
         [ActiveContext]
         [ActiveContext]
         (Identity [ActiveContext]))
-> AnIso
     (Sensitive [ActiveContext])
     (Sensitive [ActiveContext])
     [ActiveContext]
     [ActiveContext]
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Exchange
  [ActiveContext]
  [ActiveContext]
  [ActiveContext]
  (Identity [ActiveContext])
-> Exchange
     [ActiveContext]
     [ActiveContext]
     [ActiveContext]
     (Identity [ActiveContext])
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

-- | One to four alternative intents that may be applicable to the user\'s
-- intent.
--
-- Each alternative includes a score that indicates how confident Amazon
-- Lex is that the intent matches the user\'s intent. The intents are
-- sorted by the confidence score.
postTextResponse_alternativeIntents :: Lens.Lens' PostTextResponse (Prelude.Maybe [PredictedIntent])
postTextResponse_alternativeIntents :: (Maybe [PredictedIntent] -> f (Maybe [PredictedIntent]))
-> PostTextResponse -> f PostTextResponse
postTextResponse_alternativeIntents = (PostTextResponse -> Maybe [PredictedIntent])
-> (PostTextResponse
    -> Maybe [PredictedIntent] -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe [PredictedIntent])
     (Maybe [PredictedIntent])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe [PredictedIntent]
alternativeIntents :: Maybe [PredictedIntent]
$sel:alternativeIntents:PostTextResponse' :: PostTextResponse -> Maybe [PredictedIntent]
alternativeIntents} -> Maybe [PredictedIntent]
alternativeIntents) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe [PredictedIntent]
a -> PostTextResponse
s {$sel:alternativeIntents:PostTextResponse' :: Maybe [PredictedIntent]
alternativeIntents = Maybe [PredictedIntent]
a} :: PostTextResponse) ((Maybe [PredictedIntent] -> f (Maybe [PredictedIntent]))
 -> PostTextResponse -> f PostTextResponse)
-> ((Maybe [PredictedIntent] -> f (Maybe [PredictedIntent]))
    -> Maybe [PredictedIntent] -> f (Maybe [PredictedIntent]))
-> (Maybe [PredictedIntent] -> f (Maybe [PredictedIntent]))
-> PostTextResponse
-> f PostTextResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [PredictedIntent]
  [PredictedIntent]
  [PredictedIntent]
  [PredictedIntent]
-> Iso
     (Maybe [PredictedIntent])
     (Maybe [PredictedIntent])
     (Maybe [PredictedIntent])
     (Maybe [PredictedIntent])
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 AnIso
  [PredictedIntent]
  [PredictedIntent]
  [PredictedIntent]
  [PredictedIntent]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The format of the response message. One of the following values:
--
-- -   @PlainText@ - The message contains plain UTF-8 text.
--
-- -   @CustomPayload@ - The message is a custom format defined by the
--     Lambda function.
--
-- -   @SSML@ - The message contains text formatted for voice output.
--
-- -   @Composite@ - The message contains an escaped JSON object containing
--     one or more messages from the groups that messages were assigned to
--     when the intent was created.
postTextResponse_messageFormat :: Lens.Lens' PostTextResponse (Prelude.Maybe MessageFormatType)
postTextResponse_messageFormat :: (Maybe MessageFormatType -> f (Maybe MessageFormatType))
-> PostTextResponse -> f PostTextResponse
postTextResponse_messageFormat = (PostTextResponse -> Maybe MessageFormatType)
-> (PostTextResponse
    -> Maybe MessageFormatType -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe MessageFormatType)
     (Maybe MessageFormatType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe MessageFormatType
messageFormat :: Maybe MessageFormatType
$sel:messageFormat:PostTextResponse' :: PostTextResponse -> Maybe MessageFormatType
messageFormat} -> Maybe MessageFormatType
messageFormat) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe MessageFormatType
a -> PostTextResponse
s {$sel:messageFormat:PostTextResponse' :: Maybe MessageFormatType
messageFormat = Maybe MessageFormatType
a} :: PostTextResponse)

-- | The message to convey to the user. The message can come from the bot\'s
-- configuration or from a Lambda function.
--
-- If the intent is not configured with a Lambda function, or if the Lambda
-- function returned @Delegate@ as the @dialogAction.type@ its response,
-- Amazon Lex decides on the next course of action and selects an
-- appropriate message from the bot\'s configuration based on the current
-- interaction context. For example, if Amazon Lex isn\'t able to
-- understand user input, it uses a clarification prompt message.
--
-- When you create an intent you can assign messages to groups. When
-- messages are assigned to groups Amazon Lex returns one message from each
-- group in the response. The message field is an escaped JSON string
-- containing the messages. For more information about the structure of the
-- JSON string returned, see msg-prompts-formats.
--
-- If the Lambda function returns a message, Amazon Lex passes it to the
-- client in its response.
postTextResponse_message :: Lens.Lens' PostTextResponse (Prelude.Maybe Prelude.Text)
postTextResponse_message :: (Maybe Text -> f (Maybe Text))
-> PostTextResponse -> f PostTextResponse
postTextResponse_message = (PostTextResponse -> Maybe (Sensitive Text))
-> (PostTextResponse -> Maybe (Sensitive Text) -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe (Sensitive Text))
     (Maybe (Sensitive Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe (Sensitive Text)
message :: Maybe (Sensitive Text)
$sel:message:PostTextResponse' :: PostTextResponse -> Maybe (Sensitive Text)
message} -> Maybe (Sensitive Text)
message) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe (Sensitive Text)
a -> PostTextResponse
s {$sel:message:PostTextResponse' :: Maybe (Sensitive Text)
message = Maybe (Sensitive Text)
a} :: PostTextResponse) ((Maybe (Sensitive Text) -> f (Maybe (Sensitive Text)))
 -> PostTextResponse -> f PostTextResponse)
-> ((Maybe Text -> f (Maybe Text))
    -> Maybe (Sensitive Text) -> f (Maybe (Sensitive Text)))
-> (Maybe Text -> f (Maybe Text))
-> PostTextResponse
-> f PostTextResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso (Sensitive Text) (Sensitive Text) Text Text
-> Iso
     (Maybe (Sensitive Text))
     (Maybe (Sensitive Text))
     (Maybe Text)
     (Maybe Text)
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 AnIso (Sensitive Text) (Sensitive Text) Text Text
forall a. Iso' (Sensitive a) a
Core._Sensitive

-- | A unique identifier for the session.
postTextResponse_sessionId :: Lens.Lens' PostTextResponse (Prelude.Maybe Prelude.Text)
postTextResponse_sessionId :: (Maybe Text -> f (Maybe Text))
-> PostTextResponse -> f PostTextResponse
postTextResponse_sessionId = (PostTextResponse -> Maybe Text)
-> (PostTextResponse -> Maybe Text -> PostTextResponse)
-> Lens PostTextResponse PostTextResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe Text
sessionId :: Maybe Text
$sel:sessionId:PostTextResponse' :: PostTextResponse -> Maybe Text
sessionId} -> Maybe Text
sessionId) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe Text
a -> PostTextResponse
s {$sel:sessionId:PostTextResponse' :: Maybe Text
sessionId = Maybe Text
a} :: PostTextResponse)

-- | If the @dialogState@ value is @ElicitSlot@, returns the name of the slot
-- for which Amazon Lex is eliciting a value.
postTextResponse_slotToElicit :: Lens.Lens' PostTextResponse (Prelude.Maybe Prelude.Text)
postTextResponse_slotToElicit :: (Maybe Text -> f (Maybe Text))
-> PostTextResponse -> f PostTextResponse
postTextResponse_slotToElicit = (PostTextResponse -> Maybe Text)
-> (PostTextResponse -> Maybe Text -> PostTextResponse)
-> Lens PostTextResponse PostTextResponse (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe Text
slotToElicit :: Maybe Text
$sel:slotToElicit:PostTextResponse' :: PostTextResponse -> Maybe Text
slotToElicit} -> Maybe Text
slotToElicit) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe Text
a -> PostTextResponse
s {$sel:slotToElicit:PostTextResponse' :: Maybe Text
slotToElicit = Maybe Text
a} :: PostTextResponse)

-- | A map of key-value pairs representing the session-specific context
-- information.
postTextResponse_sessionAttributes :: Lens.Lens' PostTextResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
postTextResponse_sessionAttributes :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostTextResponse -> f PostTextResponse
postTextResponse_sessionAttributes = (PostTextResponse -> Maybe (Sensitive (HashMap Text Text)))
-> (PostTextResponse
    -> Maybe (Sensitive (HashMap Text Text)) -> PostTextResponse)
-> Lens
     PostTextResponse
     PostTextResponse
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PostTextResponse' {Maybe (Sensitive (HashMap Text Text))
sessionAttributes :: Maybe (Sensitive (HashMap Text Text))
$sel:sessionAttributes:PostTextResponse' :: PostTextResponse -> Maybe (Sensitive (HashMap Text Text))
sessionAttributes} -> Maybe (Sensitive (HashMap Text Text))
sessionAttributes) (\s :: PostTextResponse
s@PostTextResponse' {} Maybe (Sensitive (HashMap Text Text))
a -> PostTextResponse
s {$sel:sessionAttributes:PostTextResponse' :: Maybe (Sensitive (HashMap Text Text))
sessionAttributes = Maybe (Sensitive (HashMap Text Text))
a} :: PostTextResponse) ((Maybe (Sensitive (HashMap Text Text))
  -> f (Maybe (Sensitive (HashMap Text Text))))
 -> PostTextResponse -> f PostTextResponse)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (Sensitive (HashMap Text Text))
    -> f (Maybe (Sensitive (HashMap Text Text))))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> PostTextResponse
-> f PostTextResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (Sensitive (HashMap Text Text)))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 (AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
forall a. Iso' (Sensitive a) a
Core._Sensitive AnIso
  (Sensitive (HashMap Text Text))
  (Sensitive (HashMap Text Text))
  (HashMap Text Text)
  (HashMap Text Text)
-> (Exchange
      (HashMap Text Text)
      (HashMap Text Text)
      (HashMap Text Text)
      (Identity (HashMap Text Text))
    -> Exchange
         (HashMap Text Text)
         (HashMap Text Text)
         (HashMap Text Text)
         (Identity (HashMap Text Text)))
-> AnIso
     (Sensitive (HashMap Text Text))
     (Sensitive (HashMap Text Text))
     (HashMap Text Text)
     (HashMap Text Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. Exchange
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (Identity (HashMap Text Text))
-> Exchange
     (HashMap Text Text)
     (HashMap Text Text)
     (HashMap Text Text)
     (Identity (HashMap Text Text))
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced)

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

instance Prelude.NFData PostTextResponse