/// <summary>
/// Sends user input (text or speech) to Amazon Lex. Clients use this API to send text
/// and audio requests to Amazon Lex at runtime. Amazon Lex interprets the user input
/// using the machine learning model that it built for the bot.
///
///
/// <para>
/// The <code>PostContent</code> operation supports audio input at 8kHz and 16kHz. You
/// can use 8kHz audio to achieve higher speech recognition accuracy in telephone audio
/// applications.
/// </para>
///
/// <para>
/// In response, Amazon Lex returns the next message to convey to the user. 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, <code>PizzaSize</code>): "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 get user confirmation: "Order the pizza?".
/// </para>
/// </li> <li>
/// <para>
/// After the user replies "Yes" to the confirmation prompt, 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 response from the user. For example, conclusion
/// statements do not require a response. Some messages require only a yes or no response.
/// In addition to the <code>message</code>, Amazon Lex provides additional context about
/// the message in the response that you can use to enhance client behavior, such as displaying
/// the appropriate client user interface. 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>x-amz-lex-dialog-state</code> header set to <code>ElicitSlot</code>
/// </para>
/// </li> <li>
/// <para>
/// <code>x-amz-lex-intent-name</code> header set to the intent name in the current context
///
/// </para>
/// </li> <li>
/// <para>
/// <code>x-amz-lex-slot-to-elicit</code> header set to the slot name for which the <code>message</code>
/// is eliciting information
/// </para>
/// </li> <li>
/// <para>
/// <code>x-amz-lex-slots</code> header set to a map of slots configured for the intent
/// with their current values
/// </para>
/// </li> </ul> </li> <li>
/// <para>
/// If the message is a confirmation prompt, the <code>x-amz-lex-dialog-state</code>
/// header is set to <code>Confirmation</code> and the <code>x-amz-lex-slot-to-elicit</code>
/// header is omitted.
/// </para>
/// </li> <li>
/// <para>
/// If the message is a clarification prompt configured for the intent, indicating that
/// the user intent is not understood, the <code>x-amz-dialog-state</code> header is set
/// to <code>ElicitIntent</code> and the <code>x-amz-slot-to-elicit</code> header is omitted.
///
/// </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 PostContent service method.</param>
///
/// <returns>The response from the PostContent 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.NotAcceptableException">
/// The accept header in the request does not have a valid value.
/// </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>
/// <exception cref="Amazon.Lex.Model.RequestTimeoutException">
/// The input speech is too long.
/// </exception>
/// <exception cref="Amazon.Lex.Model.UnsupportedMediaTypeException">
/// The Content-Type header (<code>PostContent</code> API) has an invalid value.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostContent">REST API Reference for PostContent Operation</seealso>
public virtual PostContentResponse PostContent(PostContentRequest request)
{
var marshaller = new PostContentRequestMarshaller();
var unmarshaller = PostContentResponseUnmarshaller.Instance;
return(Invoke <PostContentRequest, PostContentResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the PostContent operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PostContent 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 EndPostContent
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostContent">REST API Reference for PostContent Operation</seealso>
public virtual IAsyncResult BeginPostContent(PostContentRequest request, AsyncCallback callback, object state)
{
var marshaller = new PostContentRequestMarshaller();
var unmarshaller = PostContentResponseUnmarshaller.Instance;
return(BeginInvoke <PostContentRequest>(request, marshaller, unmarshaller,
callback, state));
}
/// <summary>
/// Initiates the asynchronous execution of the PostContent operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PostContent 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/PostContent">REST API Reference for PostContent Operation</seealso>
public Task <PostContentResponse> PostContentAsync(PostContentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PostContentRequestMarshaller();
var unmarshaller = PostContentResponseUnmarshaller.Instance;
return(InvokeAsync <PostContentRequest, PostContentResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public void PostContentMarshallTest()
{
var operation = service_model.FindOperation("PostContent");
var request = InstantiateClassGenerator.Execute <PostContentRequest>();
var marshaller = new PostContentRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
TestTools.RequestValidator.Validate("PostContent", request, internalRequest, service_model);
var webResponse = new WebResponseData
{
Headers =
{
{ "Content-Type", "Content-Type_Value" },
{ "x-amz-lex-dialog-state", "x-amz-lex-dialog-state_Value" },
{ "x-amz-lex-input-transcript", "x-amz-lex-input-transcript_Value" },
{ "x-amz-lex-intent-name", "x-amz-lex-intent-name_Value" },
{ "x-amz-lex-message", "x-amz-lex-message_Value" },
{ "x-amz-lex-message-format", "x-amz-lex-message-format_Value" },
{ "x-amz-lex-sentiment", "x-amz-lex-sentiment_Value" },
{ "x-amz-lex-session-attributes", Convert.ToBase64String(Encoding.UTF8.GetBytes("x-amz-lex-session-attributes_Value")) },
{ "x-amz-lex-session-id", "x-amz-lex-session-id_Value" },
{ "x-amz-lex-slots", Convert.ToBase64String(Encoding.UTF8.GetBytes("x-amz-lex-slots_Value")) },
{ "x-amz-lex-slot-to-elicit", "x-amz-lex-slot-to-elicit_Value" },
{ "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 = PostContentResponseUnmarshaller.Instance;
var response = unmarshaller.Unmarshall(context)
as PostContentResponse;
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}