/** * 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 namespace Aws { template class AmazonWebServiceResult; namespace LexRuntimeService { namespace Model { class PostContentResult { public: AWS_LEXRUNTIMESERVICE_API PostContentResult(); //We have to define these because Microsoft doesn't auto generate them AWS_LEXRUNTIMESERVICE_API PostContentResult(PostContentResult&&); AWS_LEXRUNTIMESERVICE_API PostContentResult& operator=(PostContentResult&&); //we delete these because Microsoft doesn't handle move generation correctly //and we therefore don't trust them to get it right here either. PostContentResult(const PostContentResult&) = delete; PostContentResult& operator=(const PostContentResult&) = delete; AWS_LEXRUNTIMESERVICE_API PostContentResult(Aws::AmazonWebServiceResult&& result); AWS_LEXRUNTIMESERVICE_API PostContentResult& operator=(Aws::AmazonWebServiceResult&& result); /** *

Content type as specified in the Accept HTTP header in the * request.

*/ inline const Aws::String& GetContentType() const{ return m_contentType; } /** *

Content type as specified in the Accept HTTP header in the * request.

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

Content type as specified in the Accept HTTP header in the * request.

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

Content type as specified in the Accept HTTP header in the * request.

*/ inline void SetContentType(const char* value) { m_contentType.assign(value); } /** *

Content type as specified in the Accept HTTP header in the * request.

*/ inline PostContentResult& WithContentType(const Aws::String& value) { SetContentType(value); return *this;} /** *

Content type as specified in the Accept HTTP header in the * request.

*/ inline PostContentResult& WithContentType(Aws::String&& value) { SetContentType(std::move(value)); return *this;} /** *

Content type as specified in the Accept HTTP header in the * request.

*/ inline PostContentResult& WithContentType(const char* value) { SetContentType(value); return *this;} /** *

Current user intent that Amazon Lex is aware of.

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

Current user intent that Amazon Lex is aware of.

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

Current user intent that Amazon Lex is aware of.

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

Current user intent that Amazon Lex is aware of.

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

Current user intent that Amazon Lex is aware of.

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

Current user intent that Amazon Lex is aware of.

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

Current user intent that Amazon Lex is aware of.

*/ inline PostContentResult& 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.

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

*/ inline const Aws::String& 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.

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

*/ inline void SetNluIntentConfidence(const Aws::String& 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.

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

*/ inline void SetNluIntentConfidence(Aws::String&& 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.

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

*/ inline void SetNluIntentConfidence(const char* value) { m_nluIntentConfidence.assign(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.

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

*/ inline PostContentResult& WithNluIntentConfidence(const Aws::String& 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.

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

*/ inline PostContentResult& WithNluIntentConfidence(Aws::String&& value) { SetNluIntentConfidence(std::move(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.

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

*/ inline PostContentResult& WithNluIntentConfidence(const char* value) { SetNluIntentConfidence(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::String& 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::String& 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::String&& 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 void SetAlternativeIntents(const char* value) { m_alternativeIntents.assign(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 PostContentResult& WithAlternativeIntents(const Aws::String& 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 PostContentResult& WithAlternativeIntents(Aws::String&& 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 PostContentResult& WithAlternativeIntents(const char* value) { SetAlternativeIntents(value); return *this;} /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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::String& GetSlots() const{ return m_slots; } /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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::String& value) { m_slots = value; } /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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::String&& value) { m_slots = std::move(value); } /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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 char* value) { m_slots.assign(value); } /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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 PostContentResult& WithSlots(const Aws::String& value) { SetSlots(value); return *this;} /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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 PostContentResult& WithSlots(Aws::String&& value) { SetSlots(std::move(value)); return *this;} /** *

Map of zero or more intent slots (name/value pairs) Amazon Lex detected from * the user input during the conversation. The field is base-64 encoded.

*

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 PostContentResult& WithSlots(const char* value) { SetSlots(value); return *this;} /** *

Map of key/value pairs representing the session-specific context * information.

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

Map of key/value pairs representing the session-specific context * information.

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

Map of key/value pairs representing the session-specific context * information.

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

Map of key/value pairs representing the session-specific context * information.

*/ inline void SetSessionAttributes(const char* value) { m_sessionAttributes.assign(value); } /** *

Map of key/value pairs representing the session-specific context * information.

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

Map of key/value pairs representing the session-specific context * information.

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

Map of key/value pairs representing the session-specific context * information.

*/ inline PostContentResult& WithSessionAttributes(const char* value) { SetSessionAttributes(value); return *this;} /** *

The sentiment expressed in an 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 Aws::String& GetSentimentResponse() const{ return m_sentimentResponse; } /** *

The sentiment expressed in an 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 Aws::String& value) { m_sentimentResponse = value; } /** *

The sentiment expressed in an 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(Aws::String&& value) { m_sentimentResponse = std::move(value); } /** *

The sentiment expressed in an 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 char* value) { m_sentimentResponse.assign(value); } /** *

The sentiment expressed in an utterance.

When the bot is configured to * send utterances to Amazon Comprehend for sentiment analysis, this field contains * the result of the analysis.

*/ inline PostContentResult& WithSentimentResponse(const Aws::String& value) { SetSentimentResponse(value); return *this;} /** *

The sentiment expressed in an utterance.

When the bot is configured to * send utterances to Amazon Comprehend for sentiment analysis, this field contains * the result of the analysis.

*/ inline PostContentResult& WithSentimentResponse(Aws::String&& value) { SetSentimentResponse(std::move(value)); return *this;} /** *

The sentiment expressed in an utterance.

When the bot is configured to * send utterances to Amazon Comprehend for sentiment analysis, this field contains * the result of the analysis.

*/ inline PostContentResult& WithSentimentResponse(const char* value) { SetSentimentResponse(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 in 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.

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline const Aws::String& GetEncodedMessage() const{ return m_encodedMessage; } /** *

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

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline void SetEncodedMessage(const Aws::String& value) { m_encodedMessage = 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 in 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.

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline void SetEncodedMessage(Aws::String&& value) { m_encodedMessage = 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 in 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.

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline void SetEncodedMessage(const char* value) { m_encodedMessage.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 in 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.

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline PostContentResult& WithEncodedMessage(const Aws::String& value) { SetEncodedMessage(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 in 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.

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline PostContentResult& WithEncodedMessage(Aws::String&& value) { SetEncodedMessage(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 in 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.

The * encodedMessage field is base-64 encoded. You must decode the field * before you can use the value.

*/ inline PostContentResult& WithEncodedMessage(const char* value) { SetEncodedMessage(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 for * the client.

  • 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 for * the client.

  • 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 for * the client.

  • 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 for * the client.

  • 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 PostContentResult& 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 for * the client.

  • 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 PostContentResult& 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 the user's intent. * Consider the following examples:

    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 dialog state.

  • * 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" response, a user might respond with * additional information. For example, "yes, but make it a 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 or change the intent * from OrderPizza to OrderDrink).

  • ElicitSlot - * Amazon Lex is expecting the value of a slot 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 has successfully fulfilled the intent.

  • * ReadyForFulfillment - Conveys that the client has to fulfill the * request.

  • Failed - Conveys that the conversation * with the user failed.

    This can happen for various reasons, including * that the user does 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 if the Lambda function fails 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 the user's intent. * Consider the following examples:

    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 dialog state.

  • * 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" response, a user might respond with * additional information. For example, "yes, but make it a 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 or change the intent * from OrderPizza to OrderDrink).

  • ElicitSlot - * Amazon Lex is expecting the value of a slot 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 has successfully fulfilled the intent.

  • * ReadyForFulfillment - Conveys that the client has to fulfill the * request.

  • Failed - Conveys that the conversation * with the user failed.

    This can happen for various reasons, including * that the user does 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 if the Lambda function fails 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 the user's intent. * Consider the following examples:

    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 dialog state.

  • * 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" response, a user might respond with * additional information. For example, "yes, but make it a 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 or change the intent * from OrderPizza to OrderDrink).

  • ElicitSlot - * Amazon Lex is expecting the value of a slot 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 has successfully fulfilled the intent.

  • * ReadyForFulfillment - Conveys that the client has to fulfill the * request.

  • Failed - Conveys that the conversation * with the user failed.

    This can happen for various reasons, including * that the user does 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 if the Lambda function fails 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 the user's intent. * Consider the following examples:

    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 dialog state.

  • * 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" response, a user might respond with * additional information. For example, "yes, but make it a 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 or change the intent * from OrderPizza to OrderDrink).

  • ElicitSlot - * Amazon Lex is expecting the value of a slot 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 has successfully fulfilled the intent.

  • * ReadyForFulfillment - Conveys that the client has to fulfill the * request.

  • Failed - Conveys that the conversation * with the user failed.

    This can happen for various reasons, including * that the user does 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 if the Lambda function fails to fulfill the intent. *

*/ inline PostContentResult& 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 the user's intent. * Consider the following examples:

    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 dialog state.

  • * 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" response, a user might respond with * additional information. For example, "yes, but make it a 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 or change the intent * from OrderPizza to OrderDrink).

  • ElicitSlot - * Amazon Lex is expecting the value of a slot 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 has successfully fulfilled the intent.

  • * ReadyForFulfillment - Conveys that the client has to fulfill the * request.

  • Failed - Conveys that the conversation * with the user failed.

    This can happen for various reasons, including * that the user does 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 if the Lambda function fails to fulfill the intent. *

*/ inline PostContentResult& 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 PostContentResult& 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 PostContentResult& 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 PostContentResult& WithSlotToElicit(const char* value) { SetSlotToElicit(value); return *this;} /** *

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

*/ inline const Aws::String& GetEncodedInputTranscript() const{ return m_encodedInputTranscript; } /** *

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

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

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

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

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

*/ inline void SetEncodedInputTranscript(const char* value) { m_encodedInputTranscript.assign(value); } /** *

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

*/ inline PostContentResult& WithEncodedInputTranscript(const Aws::String& value) { SetEncodedInputTranscript(value); return *this;} /** *

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

*/ inline PostContentResult& WithEncodedInputTranscript(Aws::String&& value) { SetEncodedInputTranscript(std::move(value)); return *this;} /** *

The text used to process the request.

If the input was an audio * stream, the encodedInputTranscript field contains the text * extracted from the audio stream. This is the text that is actually processed to * recognize intents and slot values. You can use this information to determine if * Amazon Lex is correctly processing the audio that you send.

The * encodedInputTranscript field is base-64 encoded. You must decode * the field before you can use the value.

*/ inline PostContentResult& WithEncodedInputTranscript(const char* value) { SetEncodedInputTranscript(value); return *this;} /** *

The prompt (or statement) to convey to the user. This is based on the bot * configuration and context. For example, if Amazon Lex did not understand the * user intent, it sends the clarificationPrompt configured for the * bot. If the intent requires confirmation before taking the fulfillment action, * it sends the confirmationPrompt. Another example: Suppose that the * Lambda function successfully fulfilled the intent, and sent a message to convey * to the user. Then Amazon Lex sends that message in the response.

*/ inline Aws::IOStream& GetAudioStream() const { return m_audioStream.GetUnderlyingStream(); } /** *

The prompt (or statement) to convey to the user. This is based on the bot * configuration and context. For example, if Amazon Lex did not understand the * user intent, it sends the clarificationPrompt configured for the * bot. If the intent requires confirmation before taking the fulfillment action, * it sends the confirmationPrompt. Another example: Suppose that the * Lambda function successfully fulfilled the intent, and sent a message to convey * to the user. Then Amazon Lex sends that message in the response.

*/ inline void ReplaceBody(Aws::IOStream* body) { m_audioStream = Aws::Utils::Stream::ResponseStream(body); } /** *

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 PostContentResult& 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 PostContentResult& 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 PostContentResult& WithBotVersion(const char* value) { SetBotVersion(value); return *this;} /** *

The unique identifier for the session.

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

The unique identifier for the session.

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

The unique identifier for the session.

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

The unique identifier for the session.

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

The unique identifier for the session.

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

The unique identifier for the session.

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

The unique identifier for the session.

*/ inline PostContentResult& WithSessionId(const char* value) { SetSessionId(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::String& 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::String& 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::String&& 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 void SetActiveContexts(const char* value) { m_activeContexts.assign(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 PostContentResult& WithActiveContexts(const Aws::String& 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 PostContentResult& WithActiveContexts(Aws::String&& 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 PostContentResult& WithActiveContexts(const char* value) { SetActiveContexts(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 PostContentResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;} inline PostContentResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;} inline PostContentResult& WithRequestId(const char* value) { SetRequestId(value); return *this;} private: Aws::String m_contentType; Aws::String m_intentName; Aws::String m_nluIntentConfidence; Aws::String m_alternativeIntents; Aws::String m_slots; Aws::String m_sessionAttributes; Aws::String m_sentimentResponse; Aws::String m_encodedMessage; MessageFormatType m_messageFormat; DialogState m_dialogState; Aws::String m_slotToElicit; Aws::String m_encodedInputTranscript; Aws::Utils::Stream::ResponseStream m_audioStream; Aws::String m_botVersion; Aws::String m_sessionId; Aws::String m_activeContexts; Aws::String m_requestId; }; } // namespace Model } // namespace LexRuntimeService } // namespace Aws