/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include namespace Aws { template class AmazonWebServiceResult; namespace Utils { namespace Json { class JsonValue; } // namespace Json } // namespace Utils namespace LexRuntimeService { namespace Model { class PostTextResult { public: AWS_LEXRUNTIMESERVICE_API PostTextResult(); AWS_LEXRUNTIMESERVICE_API PostTextResult(const Aws::AmazonWebServiceResult& result); AWS_LEXRUNTIMESERVICE_API PostTextResult& operator=(const Aws::AmazonWebServiceResult& result); /** *

The current user intent that Amazon Lex is aware of.

*/ inline const Aws::String& GetIntentName() const{ return m_intentName; } /** *

The current user intent that Amazon Lex is aware of.

*/ inline void SetIntentName(const Aws::String& value) { m_intentName = value; } /** *

The current user intent that Amazon Lex is aware of.

*/ inline void SetIntentName(Aws::String&& value) { m_intentName = std::move(value); } /** *

The current user intent that Amazon Lex is aware of.

*/ inline void SetIntentName(const char* value) { m_intentName.assign(value); } /** *

The current user intent that Amazon Lex is aware of.

*/ inline PostTextResult& WithIntentName(const Aws::String& value) { SetIntentName(value); return *this;} /** *

The current user intent that Amazon Lex is aware of.

*/ inline PostTextResult& WithIntentName(Aws::String&& value) { SetIntentName(std::move(value)); return *this;} /** *

The current user intent that Amazon Lex is aware of.

*/ inline PostTextResult& WithIntentName(const char* value) { SetIntentName(value); return *this;} /** *

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 Confidence * Scores.

The score is a relative score, not an absolute score. The * score may change based on improvements to Amazon Lex.

*/ inline const IntentConfidence& GetNluIntentConfidence() const{ return m_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 Confidence * Scores.

The score is a relative score, not an absolute score. The * score may change based on improvements to Amazon Lex.

*/ inline void SetNluIntentConfidence(const IntentConfidence& value) { m_nluIntentConfidence = value; } /** *

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 Confidence * Scores.

The score is a relative score, not an absolute score. The * score may change based on improvements to Amazon Lex.

*/ inline void SetNluIntentConfidence(IntentConfidence&& value) { m_nluIntentConfidence = std::move(value); } /** *

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 Confidence * Scores.

The score is a relative score, not an absolute score. The * score may change based on improvements to Amazon Lex.

*/ inline PostTextResult& WithNluIntentConfidence(const IntentConfidence& value) { SetNluIntentConfidence(value); return *this;} /** *

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 Confidence * Scores.

The score is a relative score, not an absolute score. The * score may change based on improvements to Amazon Lex.

*/ inline PostTextResult& WithNluIntentConfidence(IntentConfidence&& value) { SetNluIntentConfidence(std::move(value)); return *this;} /** *

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.

*/ inline const Aws::Vector& GetAlternativeIntents() const{ return m_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.

*/ inline void SetAlternativeIntents(const Aws::Vector& value) { m_alternativeIntents = value; } /** *

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.

*/ inline void SetAlternativeIntents(Aws::Vector&& value) { m_alternativeIntents = std::move(value); } /** *

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.

*/ inline PostTextResult& WithAlternativeIntents(const Aws::Vector& value) { SetAlternativeIntents(value); return *this;} /** *

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.

*/ inline PostTextResult& WithAlternativeIntents(Aws::Vector&& value) { SetAlternativeIntents(std::move(value)); return *this;} /** *

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.

*/ inline PostTextResult& AddAlternativeIntents(const PredictedIntent& value) { m_alternativeIntents.push_back(value); return *this; } /** *

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.

*/ inline PostTextResult& AddAlternativeIntents(PredictedIntent&& value) { m_alternativeIntents.push_back(std::move(value)); return *this; } /** *

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.

*/ inline const Aws::Map& GetSlots() const{ return m_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.

*/ inline void SetSlots(const Aws::Map& value) { m_slots = value; } /** *

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.

*/ inline void SetSlots(Aws::Map&& value) { m_slots = std::move(value); } /** *

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.

*/ inline PostTextResult& WithSlots(const Aws::Map& value) { SetSlots(value); return *this;} /** *

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.

*/ inline PostTextResult& WithSlots(Aws::Map&& value) { SetSlots(std::move(value)); return *this;} /** *

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.

*/ inline PostTextResult& AddSlots(const Aws::String& key, const Aws::String& value) { m_slots.emplace(key, value); return *this; } /** *

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.

*/ inline PostTextResult& AddSlots(Aws::String&& key, const Aws::String& value) { m_slots.emplace(std::move(key), value); return *this; } /** *

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.

*/ inline PostTextResult& AddSlots(const Aws::String& key, Aws::String&& value) { m_slots.emplace(key, std::move(value)); return *this; } /** *

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.

*/ inline PostTextResult& AddSlots(Aws::String&& key, Aws::String&& value) { m_slots.emplace(std::move(key), std::move(value)); return *this; } /** *

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.

*/ inline PostTextResult& AddSlots(const char* key, Aws::String&& value) { m_slots.emplace(key, std::move(value)); return *this; } /** *

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.

*/ inline PostTextResult& AddSlots(Aws::String&& key, const char* value) { m_slots.emplace(std::move(key), value); return *this; } /** *

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.

*/ inline PostTextResult& AddSlots(const char* key, const char* value) { m_slots.emplace(key, value); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline const Aws::Map& GetSessionAttributes() const{ return m_sessionAttributes; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline void SetSessionAttributes(const Aws::Map& value) { m_sessionAttributes = value; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline void SetSessionAttributes(Aws::Map&& value) { m_sessionAttributes = std::move(value); } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& WithSessionAttributes(const Aws::Map& value) { SetSessionAttributes(value); return *this;} /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& WithSessionAttributes(Aws::Map&& value) { SetSessionAttributes(std::move(value)); return *this;} /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(const Aws::String& key, const Aws::String& value) { m_sessionAttributes.emplace(key, value); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(Aws::String&& key, const Aws::String& value) { m_sessionAttributes.emplace(std::move(key), value); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(const Aws::String& key, Aws::String&& value) { m_sessionAttributes.emplace(key, std::move(value)); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(Aws::String&& key, Aws::String&& value) { m_sessionAttributes.emplace(std::move(key), std::move(value)); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(const char* key, Aws::String&& value) { m_sessionAttributes.emplace(key, std::move(value)); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(Aws::String&& key, const char* value) { m_sessionAttributes.emplace(std::move(key), value); return *this; } /** *

A map of key-value pairs representing the session-specific context * information.

*/ inline PostTextResult& AddSessionAttributes(const char* key, const char* value) { m_sessionAttributes.emplace(key, value); return *this; } /** *

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.

*/ inline const Aws::String& GetMessage() const{ return m_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.

*/ inline void SetMessage(const Aws::String& value) { m_message = value; } /** *

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.

*/ inline void SetMessage(Aws::String&& value) { m_message = std::move(value); } /** *

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.

*/ inline void SetMessage(const char* value) { m_message.assign(value); } /** *

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.

*/ inline PostTextResult& WithMessage(const Aws::String& value) { SetMessage(value); return *this;} /** *

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.

*/ inline PostTextResult& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;} /** *

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.

*/ inline PostTextResult& WithMessage(const char* value) { SetMessage(value); return *this;} /** *

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.

*/ inline const SentimentResponse& GetSentimentResponse() const{ return m_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.

*/ inline void SetSentimentResponse(const SentimentResponse& value) { m_sentimentResponse = value; } /** *

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.

*/ inline void SetSentimentResponse(SentimentResponse&& value) { m_sentimentResponse = std::move(value); } /** *

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.

*/ inline PostTextResult& WithSentimentResponse(const SentimentResponse& value) { SetSentimentResponse(value); return *this;} /** *

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.

*/ inline PostTextResult& WithSentimentResponse(SentimentResponse&& value) { SetSentimentResponse(std::move(value)); return *this;} /** *

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.

*/ inline const MessageFormatType& GetMessageFormat() const{ return m_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.

*/ inline void SetMessageFormat(const MessageFormatType& value) { m_messageFormat = value; } /** *

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.

*/ inline void SetMessageFormat(MessageFormatType&& value) { m_messageFormat = std::move(value); } /** *

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.

*/ inline PostTextResult& WithMessageFormat(const MessageFormatType& value) { SetMessageFormat(value); return *this;} /** *

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.

*/ inline PostTextResult& WithMessageFormat(MessageFormatType&& value) { SetMessageFormat(std::move(value)); return *this;} /** *

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.

*/ inline const DialogState& GetDialogState() const{ return m_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.

*/ inline void SetDialogState(const DialogState& value) { m_dialogState = value; } /** *

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.

*/ inline void SetDialogState(DialogState&& value) { m_dialogState = std::move(value); } /** *

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.

*/ inline PostTextResult& WithDialogState(const DialogState& value) { SetDialogState(value); return *this;} /** *

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.

*/ inline PostTextResult& WithDialogState(DialogState&& value) { SetDialogState(std::move(value)); return *this;} /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline const Aws::String& GetSlotToElicit() const{ return m_slotToElicit; } /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline void SetSlotToElicit(const Aws::String& value) { m_slotToElicit = value; } /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline void SetSlotToElicit(Aws::String&& value) { m_slotToElicit = std::move(value); } /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline void SetSlotToElicit(const char* value) { m_slotToElicit.assign(value); } /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline PostTextResult& WithSlotToElicit(const Aws::String& value) { SetSlotToElicit(value); return *this;} /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline PostTextResult& WithSlotToElicit(Aws::String&& value) { SetSlotToElicit(std::move(value)); return *this;} /** *

If the dialogState value is ElicitSlot, returns the * name of the slot for which Amazon Lex is eliciting a value.

*/ inline PostTextResult& WithSlotToElicit(const char* value) { SetSlotToElicit(value); return *this;} /** *

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).

*/ inline const ResponseCard& GetResponseCard() const{ return m_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).

*/ inline void SetResponseCard(const ResponseCard& value) { m_responseCard = value; } /** *

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).

*/ inline void SetResponseCard(ResponseCard&& value) { m_responseCard = std::move(value); } /** *

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).

*/ inline PostTextResult& WithResponseCard(const ResponseCard& value) { SetResponseCard(value); return *this;} /** *

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).

*/ inline PostTextResult& WithResponseCard(ResponseCard&& value) { SetResponseCard(std::move(value)); return *this;} /** *

A unique identifier for the session.

*/ inline const Aws::String& GetSessionId() const{ return m_sessionId; } /** *

A unique identifier for the session.

*/ inline void SetSessionId(const Aws::String& value) { m_sessionId = value; } /** *

A unique identifier for the session.

*/ inline void SetSessionId(Aws::String&& value) { m_sessionId = std::move(value); } /** *

A unique identifier for the session.

*/ inline void SetSessionId(const char* value) { m_sessionId.assign(value); } /** *

A unique identifier for the session.

*/ inline PostTextResult& WithSessionId(const Aws::String& value) { SetSessionId(value); return *this;} /** *

A unique identifier for the session.

*/ inline PostTextResult& WithSessionId(Aws::String&& value) { SetSessionId(std::move(value)); return *this;} /** *

A unique identifier for the session.

*/ inline PostTextResult& WithSessionId(const char* value) { SetSessionId(value); return *this;} /** *

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.

*/ inline const Aws::String& GetBotVersion() const{ return m_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.

*/ inline void SetBotVersion(const Aws::String& value) { m_botVersion = value; } /** *

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.

*/ inline void SetBotVersion(Aws::String&& value) { m_botVersion = std::move(value); } /** *

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.

*/ inline void SetBotVersion(const char* value) { m_botVersion.assign(value); } /** *

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.

*/ inline PostTextResult& WithBotVersion(const Aws::String& value) { SetBotVersion(value); return *this;} /** *

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.

*/ inline PostTextResult& WithBotVersion(Aws::String&& value) { SetBotVersion(std::move(value)); return *this;} /** *

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.

*/ inline PostTextResult& WithBotVersion(const char* value) { SetBotVersion(value); return *this;} /** *

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.

*/ inline const Aws::Vector& GetActiveContexts() const{ return m_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.

*/ inline void SetActiveContexts(const Aws::Vector& value) { m_activeContexts = value; } /** *

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.

*/ inline void SetActiveContexts(Aws::Vector&& value) { m_activeContexts = std::move(value); } /** *

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.

*/ inline PostTextResult& WithActiveContexts(const Aws::Vector& value) { SetActiveContexts(value); return *this;} /** *

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.

*/ inline PostTextResult& WithActiveContexts(Aws::Vector&& value) { SetActiveContexts(std::move(value)); return *this;} /** *

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.

*/ inline PostTextResult& AddActiveContexts(const ActiveContext& value) { m_activeContexts.push_back(value); return *this; } /** *

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.

*/ inline PostTextResult& AddActiveContexts(ActiveContext&& value) { m_activeContexts.push_back(std::move(value)); return *this; } inline const Aws::String& GetRequestId() const{ return m_requestId; } inline void SetRequestId(const Aws::String& value) { m_requestId = value; } inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); } inline void SetRequestId(const char* value) { m_requestId.assign(value); } inline PostTextResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;} inline PostTextResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;} inline PostTextResult& WithRequestId(const char* value) { SetRequestId(value); return *this;} private: Aws::String m_intentName; IntentConfidence m_nluIntentConfidence; Aws::Vector m_alternativeIntents; Aws::Map m_slots; Aws::Map m_sessionAttributes; Aws::String m_message; SentimentResponse m_sentimentResponse; MessageFormatType m_messageFormat; DialogState m_dialogState; Aws::String m_slotToElicit; ResponseCard m_responseCard; Aws::String m_sessionId; Aws::String m_botVersion; Aws::Vector m_activeContexts; Aws::String m_requestId; }; } // namespace Model } // namespace LexRuntimeService } // namespace Aws