com.amazonaws.services.lexruntime.model

Class PostTextResult

java.lang.Object

com.amazonaws.AmazonWebServiceResult<ResponseMetadata>

com.amazonaws.services.lexruntime.model.PostTextResult

All Implemented Interfaces:

Serializable, Cloneable

@Generated(value="com.amazonaws:aws-java-sdk-code-generator")
public class PostTextResult
extends AmazonWebServiceResult<ResponseMetadata>
implements Serializable, Cloneable

See Also:

AWS API Documentation, Serialized Form

Constructor Summary

Constructors

Constructor and Description
PostTextResult()

Method Summary

Modifier and Type	Method and Description
PostTextResult	addSessionAttributesEntry(String key, String value)
PostTextResult	addSlotsEntry(String key, String value)
PostTextResult	clearSessionAttributesEntries() Removes all the entries added into SessionAttributes.
PostTextResult	clearSlotsEntries() Removes all the entries added into Slots.
PostTextResult	clone()
boolean	equals(Object obj)
String	getDialogState() Represents the message type to be conveyed to the user.
String	getIntentName() Intent Amazon Lex inferred from the user input text.
String	getMessage() Prompt (or statement) to convey to the user.
ResponseCard	getResponseCard() Represents the options that the user has to respond to the current prompt.
Map<String,String>	getSessionAttributes() Map of key value pairs representing the session specific context information.
Map<String,String>	getSlots() Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.
String	getSlotToElicit() If dialogState value is ElicitSlot, returns the name of the slot for which Amazon Lex is eliciting a value.
int	hashCode()
void	setDialogState(DialogState dialogState) Represents the message type to be conveyed to the user.
void	setDialogState(String dialogState) Represents the message type to be conveyed to the user.
void	setIntentName(String intentName) Intent Amazon Lex inferred from the user input text.
void	setMessage(String message) Prompt (or statement) to convey to the user.
void	setResponseCard(ResponseCard responseCard) Represents the options that the user has to respond to the current prompt.
void	setSessionAttributes(Map<String,String> sessionAttributes) Map of key value pairs representing the session specific context information.
void	setSlots(Map<String,String> slots) Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.
void	setSlotToElicit(String slotToElicit) If dialogState value is ElicitSlot, returns the name of the slot for which Amazon Lex is eliciting a value.
String	toString() Returns a string representation of this object; useful for testing and debugging.
PostTextResult	withDialogState(DialogState dialogState) Represents the message type to be conveyed to the user.
PostTextResult	withDialogState(String dialogState) Represents the message type to be conveyed to the user.
PostTextResult	withIntentName(String intentName) Intent Amazon Lex inferred from the user input text.
PostTextResult	withMessage(String message) Prompt (or statement) to convey to the user.
PostTextResult	withResponseCard(ResponseCard responseCard) Represents the options that the user has to respond to the current prompt.
PostTextResult	withSessionAttributes(Map<String,String> sessionAttributes) Map of key value pairs representing the session specific context information.
PostTextResult	withSlots(Map<String,String> slots) Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.
PostTextResult	withSlotToElicit(String slotToElicit) If dialogState value is ElicitSlot, returns the name of the slot for which Amazon Lex is eliciting a value.

Methods inherited from class com.amazonaws.AmazonWebServiceResult

getSdkHttpMetadata, getSdkResponseMetadata, setSdkHttpMetadata, setSdkResponseMetadata

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

PostTextResult

public PostTextResult()

Method Detail

setIntentName

public void setIntentName(String intentName)

Intent Amazon Lex inferred from the user input text. This is one of the intents configured for the bot.

Parameters:

intentName - Intent Amazon Lex inferred from the user input text. This is one of the intents configured for the bot.

getIntentName

public String getIntentName()

Intent Amazon Lex inferred from the user input text. This is one of the intents configured for the bot.

Returns:

Intent Amazon Lex inferred from the user input text. This is one of the intents configured for the bot.

withIntentName

public PostTextResult withIntentName(String intentName)

Intent Amazon Lex inferred from the user input text. This is one of the intents configured for the bot.

Parameters:

intentName - Intent Amazon Lex inferred from the user input text. This is one of the intents configured for the bot.

Returns:

Returns a reference to this object so that method calls can be chained together.

getSlots

public Map<String,String> getSlots()

Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.

Returns:

Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.

setSlots

public void setSlots(Map<String,String> slots)

Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.

Parameters:

slots - Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.

withSlots

public PostTextResult withSlots(Map<String,String> slots)

Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.

Parameters:

slots - Intent slots (name/value pairs) Amazon Lex detected so far from the user input in the conversation.

Returns:

Returns a reference to this object so that method calls can be chained together.

addSlotsEntry

public PostTextResult addSlotsEntry(String key,
                                    String value)

clearSlotsEntries

public PostTextResult clearSlotsEntries()

Removes all the entries added into Slots.

Returns:

Returns a reference to this object so that method calls can be chained together.

getSessionAttributes

public Map<String,String> getSessionAttributes()

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

Returns:

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

setSessionAttributes

public void setSessionAttributes(Map<String,String> sessionAttributes)

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

Parameters:

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

withSessionAttributes

public PostTextResult withSessionAttributes(Map<String,String> sessionAttributes)

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

Parameters:

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

Returns:

Returns a reference to this object so that method calls can be chained together.

addSessionAttributesEntry

public PostTextResult addSessionAttributesEntry(String key,
                                                String value)

clearSessionAttributesEntries

public PostTextResult clearSessionAttributesEntries()

Removes all the entries added into SessionAttributes.

Returns:

Returns a reference to this object so that method calls can be chained together.

setMessage

public void setMessage(String message)

Prompt (or statement) to convey to the user. This is based on the application configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the clarificationPrompt configured for the application. In another example, if the intent requires confirmation before taking the fulfillment action, it sends the confirmationPrompt. Suppose the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. In that situation, Amazon Lex sends that message in the response.

Parameters:

message - Prompt (or statement) to convey to the user. This is based on the application configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the clarificationPrompt configured for the application. In another example, if the intent requires confirmation before taking the fulfillment action, it sends the confirmationPrompt. Suppose the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. In that situation, Amazon Lex sends that message in the response.

getMessage

public String getMessage()

Prompt (or statement) to convey to the user. This is based on the application configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the clarificationPrompt configured for the application. In another example, if the intent requires confirmation before taking the fulfillment action, it sends the confirmationPrompt. Suppose the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. In that situation, Amazon Lex sends that message in the response.

Returns:

Prompt (or statement) to convey to the user. This is based on the application configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the clarificationPrompt configured for the application. In another example, if the intent requires confirmation before taking the fulfillment action, it sends the confirmationPrompt. Suppose the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. In that situation, Amazon Lex sends that message in the response.

withMessage

public PostTextResult withMessage(String message)

Prompt (or statement) to convey to the user. This is based on the application configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the clarificationPrompt configured for the application. In another example, if the intent requires confirmation before taking the fulfillment action, it sends the confirmationPrompt. Suppose the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. In that situation, Amazon Lex sends that message in the response.

Parameters:

message - Prompt (or statement) to convey to the user. This is based on the application configuration and context. For example, if Amazon Lex did not understand the user intent, it sends the clarificationPrompt configured for the application. In another example, if the intent requires confirmation before taking the fulfillment action, it sends the confirmationPrompt. Suppose the Lambda function successfully fulfilled the intent, and sent a message to convey to the user. In that situation, Amazon Lex sends that message in the response.

Returns:

Returns a reference to this object so that method calls can be chained together.

setDialogState

public void setDialogState(String dialogState)

Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Parameters:

dialogState - Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

See Also:

DialogState

getDialogState

public String getDialogState()

Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Returns:

Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

See Also:

DialogState

withDialogState

public PostTextResult withDialogState(String dialogState)

Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Parameters:

dialogState - Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Returns:

Returns a reference to this object so that method calls can be chained together.

See Also:

DialogState

setDialogState

public void setDialogState(DialogState dialogState)

Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Parameters:

dialogState - Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

See Also:

DialogState

withDialogState

public PostTextResult withDialogState(DialogState dialogState)

Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Parameters:

dialogState - Represents the message type to be conveyed to the user. For example:

• ElicitIntent – Amazon Lex wants to elicit user intent. For example, Amazon Lex did not understand the first utterances such as "I want to order pizza", which indicates the OrderPizza intent. If Amazon Lex doesn't understand the intent, it returns this dialogState. Another example is when your intent is configured with a follow up prompt. For example, after OrderPizza intent is fulfilled, the intent might have a follow up prompt such as " Do you want to order a drink or desert?" In this case, Amazon Lex returns this dialogState.

• ConfirmIntent – Amazon Lex is expecting a yes/no response from the user indicating whether to go ahead and fulfill the intent (for example, OK to go ahead and order the pizza). In addition to a yes/no reply, the user might provide a response with additional slot information (either new slot information or changes to the existing slot values). For example, "Yes, but change to thick crust." Amazon Lex understands the additional information and updates the intent slots accordingly.

  Consider another example. Before fulfilling an order, your application might prompt for confirmation such as "Do you want to place this pizza order?" A user might reply with "No, I want to order a drink." Amazon Lex recognizes the new OrderDrink intent.

• ElicitSlot – Amazon Lex is expecting a value of a slot for the current intent. For example, suppose Amazon Lex asks, "What size pizza would you like?" A user might reply with "Medium pepperoni pizza." Amazon Lex recognizes the size and the topping as the two separate slot values.

• Fulfilled – Conveys that the Lambda function has successfully fulfilled the intent. If Lambda function returns a statement/message to convey the fulfillment result, Amazon Lex passes this string to the client. If not, Amazon Lex looks for conclusionStatement that you configured for the intent.

  If both the Lambda function statement and the conclusionStatement are missing, Amazon Lex throws a bad request exception.

• ReadyForFulfillment – conveys that the client has to do the fulfillment work for the intent. This is the case when the current intent is configured with ReturnIntent as the fulfillmentActivity , where Amazon Lex returns this state to client.

• Failed – Conversation with the user failed. Some of the reasons for this dialogState are: after the configured number of attempts the user didn't provide an appropriate response, or the Lambda function failed to fulfill an intent.

Returns:

Returns a reference to this object so that method calls can be chained together.

See Also:

DialogState

setSlotToElicit

public void setSlotToElicit(String slotToElicit)

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

Parameters:

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

getSlotToElicit

public String getSlotToElicit()

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

Returns:

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

withSlotToElicit

public PostTextResult withSlotToElicit(String slotToElicit)

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

Parameters:

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

Returns:

Returns a reference to this object so that method calls can be chained together.

setResponseCard

public void setResponseCard(ResponseCard responseCard)

Represents the options that the user has to respond to the current prompt. Amazon Lex sends this in the response only if the dialogState value indicates that a user response is expected.

Parameters:

responseCard - Represents the options that the user has to respond to the current prompt. Amazon Lex sends this in the response only if the dialogState value indicates that a user response is expected.

getResponseCard

public ResponseCard getResponseCard()

Represents the options that the user has to respond to the current prompt. Amazon Lex sends this in the response only if the dialogState value indicates that a user response is expected.

Returns:

Represents the options that the user has to respond to the current prompt. Amazon Lex sends this in the response only if the dialogState value indicates that a user response is expected.

withResponseCard

public PostTextResult withResponseCard(ResponseCard responseCard)

Represents the options that the user has to respond to the current prompt. Amazon Lex sends this in the response only if the dialogState value indicates that a user response is expected.

Parameters:

responseCard - Represents the options that the user has to respond to the current prompt. Amazon Lex sends this in the response only if the dialogState value indicates that a user response is expected.

Returns:

Returns a reference to this object so that method calls can be chained together.

toString

public String toString()

Returns a string representation of this object; useful for testing and debugging.

Overrides:

toString in class Object

Returns:

A string representation of this object.

See Also:

Object.toString()

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

clone

public PostTextResult clone()

Overrides:

clone in class Object