/// <summary>
/// Sends user input (text-only) to Amazon Lex. Client applications can use this API to
/// send requests to Amazon Lex at runtime. Amazon Lex then interprets the user input
/// using the machine learning model it built for the bot.
///
///
/// <para>
/// In response, Amazon Lex returns the next <code>message</code> to convey to the user
/// an optional <code>responseCard</code> to display. Consider the following example messages:
///
/// </para>
/// <ul> <li>
/// <para>
/// For a user input "I would like a pizza", Amazon Lex might return a response with
/// a message eliciting slot data (for example, PizzaSize): "What size pizza would you
/// like?"
/// </para>
/// </li> <li>
/// <para>
/// After the user provides all of the pizza order information, Amazon Lex might return
/// a response with a message to obtain user confirmation "Proceed with the pizza order?".
///
/// </para>
/// </li> <li>
/// <para>
/// After the user replies to a confirmation prompt with a "yes", Amazon Lex might return
/// a conclusion statement: "Thank you, your cheese pizza has been ordered.".
/// </para>
/// </li> </ul>
/// <para>
/// Not all Amazon Lex messages require a user response. For example, a conclusion statement
/// does not require a response. Some messages require only a "yes" or "no" user response.
/// In addition to the <code>message</code>, Amazon Lex provides additional context about
/// the message in the response that you might use to enhance client behavior, for example,
/// to display the appropriate client user interface. These are the <code>slotToElicit</code>,
/// <code>dialogState</code>, <code>intentName</code>, and <code>slots</code> fields in
/// the response. Consider the following examples:
/// </para>
/// <ul> <li>
/// <para>
/// If the message is to elicit slot data, Amazon Lex returns the following context information:
/// </para>
/// <ul> <li>
/// <para>
/// <code>dialogState</code> set to ElicitSlot
/// </para>
/// </li> <li>
/// <para>
/// <code>intentName</code> set to the intent name in the current context
/// </para>
/// </li> <li>
/// <para>
/// <code>slotToElicit</code> set to the slot name for which the <code>message</code>
/// is eliciting information
/// </para>
/// </li> <li>
/// <para>
/// <code>slots</code> set to a map of slots, configured for the intent, with currently
/// known values
/// </para>
/// </li> </ul> </li> <li>
/// <para>
/// If the message is a confirmation prompt, the <code>dialogState</code> is set to ConfirmIntent
/// and <code>SlotToElicit</code> is set to null.
/// </para>
/// </li> <li>
/// <para>
/// If the message is a clarification prompt (configured for the intent) that indicates
/// that user intent is not understood, the <code>dialogState</code> is set to ElicitIntent
/// and <code>slotToElicit</code> is set to null.
/// </para>
/// </li> </ul>
/// <para>
/// In addition, Amazon Lex also returns your application-specific <code>sessionAttributes</code>.
/// For more information, see <a href="http://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html">Managing
/// Conversation Context</a>.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the PostText service method.</param>
///
/// <returns>The response from the PostText service method, as returned by Lex.</returns>
/// <exception cref="Amazon.Lex.Model.BadGatewayException">
/// Either the Amazon Lex bot is still building, or one of the dependent services (Amazon
/// Polly, AWS Lambda) failed with an internal service error.
/// </exception>
/// <exception cref="Amazon.Lex.Model.BadRequestException">
/// Request validation failed, there is no usable message in the context, or the bot
/// build failed, is still in progress, or contains unbuilt changes.
/// </exception>
/// <exception cref="Amazon.Lex.Model.ConflictException">
/// Two clients are using the same AWS account, Amazon Lex bot, and user ID.
/// </exception>
/// <exception cref="Amazon.Lex.Model.DependencyFailedException">
/// One of the dependencies, such as AWS Lambda or Amazon Polly, threw an exception.
/// For example,
///
/// <ul> <li>
/// <para>
/// If Amazon Lex does not have sufficient permissions to call a Lambda function.
/// </para>
/// </li> <li>
/// <para>
/// If a Lambda function takes longer than 30 seconds to execute.
/// </para>
/// </li> <li>
/// <para>
/// If a fulfillment Lambda function returns a <code>Delegate</code> dialog action without
/// removing any slot values.
/// </para>
/// </li> </ul>
/// </exception>
/// <exception cref="Amazon.Lex.Model.InternalFailureException">
/// Internal service error. Retry the call.
/// </exception>
/// <exception cref="Amazon.Lex.Model.LimitExceededException">
/// Exceeded a limit.
/// </exception>
/// <exception cref="Amazon.Lex.Model.LoopDetectedException">
/// This exception is not used.
/// </exception>
/// <exception cref="Amazon.Lex.Model.NotFoundException">
/// The resource (such as the Amazon Lex bot or an alias) that is referred to is not found.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostText">REST API Reference for PostText Operation</seealso>
public virtual PostTextResponse PostText(PostTextRequest request)
{
var marshaller = new PostTextRequestMarshaller();
var unmarshaller = PostTextResponseUnmarshaller.Instance;
return(Invoke <PostTextRequest, PostTextResponse>(request, marshaller, unmarshaller));
}
public void PostTextMarshallTest()
{
var operation = service_model.FindOperation("PostText");
var request = InstantiateClassGenerator.Execute <PostTextRequest>();
var marshaller = new PostTextRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
TestTools.RequestValidator.Validate("PostText", request, internalRequest, service_model);
var webResponse = new WebResponseData
{
Headers =
{
{ "x-amzn-RequestId", Guid.NewGuid().ToString() },
{ "x-amz-crc32", "0" }
}
};
var payloadResponse = new JsonSampleGenerator(service_model, operation.ResponseStructure).Execute();
webResponse.Headers["Content-Length"] = UTF8Encoding.UTF8.GetBytes(payloadResponse).Length.ToString();
var context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, webResponse);
ResponseUnmarshaller unmarshaller = PostTextResponseUnmarshaller.Instance;
var response = unmarshaller.Unmarshall(context)
as PostTextResponse;
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}
/// <summary>
/// Initiates the asynchronous execution of the PostText operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PostText operation on AmazonLexClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPostText
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostText">REST API Reference for PostText Operation</seealso>
public virtual IAsyncResult BeginPostText(PostTextRequest request, AsyncCallback callback, object state)
{
var marshaller = new PostTextRequestMarshaller();
var unmarshaller = PostTextResponseUnmarshaller.Instance;
return(BeginInvoke <PostTextRequest>(request, marshaller, unmarshaller,
callback, state));
}
/// <summary>
/// Initiates the asynchronous execution of the PostText operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PostText operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostText">REST API Reference for PostText Operation</seealso>
public Task <PostTextResponse> PostTextAsync(PostTextRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PostTextRequestMarshaller();
var unmarshaller = PostTextResponseUnmarshaller.Instance;
return(InvokeAsync <PostTextRequest, PostTextResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
