def post_content(params = {}, options = {}, &block)
      req = build_request(:post_content, params)
      req.send_request(options, &block)
    end
def post_content(params = {}, options = {}, &block)
      req = build_request(:post_content, params)
      req.send_request(options, &block)
    end
@overload initialize(options)
   @param [Hash] options
   @option options [required, Aws::CredentialProvider] :credentials
     Your AWS credentials. This can be an instance of any one of the
     following classes:

     * `Aws::Credentials` - Used for configuring static, non-refreshing
       credentials.

     * `Aws::InstanceProfileCredentials` - Used for loading credentials
       from an EC2 IMDS on an EC2 instance.

     * `Aws::SharedCredentials` - Used for loading credentials from a
       shared file, such as `~/.aws/config`.

     * `Aws::AssumeRoleCredentials` - Used when you need to assume a role.

     When `:credentials` are not configured directly, the following
     locations will be searched for credentials:

     * `Aws.config[:credentials]`
     * The `:access_key_id`, `:secret_access_key`, and `:session_token` options.
     * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
     * `~/.aws/credentials`
     * `~/.aws/config`
     * EC2 IMDS instance profile - When used by default, the timeouts are
       very aggressive. Construct and pass an instance of
       `Aws::InstanceProfileCredentails` to enable retries and extended
       timeouts.

   @option options [required, String] :region
     The AWS region to connect to.  The configured `:region` is
     used to determine the service `:endpoint`. When not passed,
     a default `:region` is search for in the following locations:

     * `Aws.config[:region]`
     * `ENV['AWS_REGION']`
     * `ENV['AMAZON_REGION']`
     * `ENV['AWS_DEFAULT_REGION']`
     * `~/.aws/credentials`
     * `~/.aws/config`

   @option options [String] :access_key_id

   @option options [Boolean] :active_endpoint_cache (false)
     When set to `true`, a thread polling for endpoints will be running in
     the background every 60 secs (default). Defaults to `false`.

   @option options [Boolean] :client_side_monitoring (false)
     When `true`, client-side metrics will be collected for all API requests from
     this client.

   @option options [String] :client_side_monitoring_client_id ("")
     Allows you to provide an identifier for this client which will be attached to
     all generated client side metrics. Defaults to an empty string.

   @option options [Integer] :client_side_monitoring_port (31000)
     Required for publishing client metrics. The port that the client side monitoring
     agent is running on, where client metrics will be published via UDP.

   @option options [Aws::ClientSideMonitoring::Publisher] :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher)
     Allows you to provide a custom client-side monitoring publisher class. By default,
     will use the Client Side Monitoring Agent Publisher.

   @option options [Boolean] :convert_params (true)
     When `true`, an attempt is made to coerce request parameters into
     the required types.

   @option options [Boolean] :disable_host_prefix_injection (false)
     Set to true to disable SDK automatically adding host prefix
     to default service endpoint when available.

   @option options [String] :endpoint
     The client endpoint is normally constructed from the `:region`
     option. You should only configure an `:endpoint` when connecting
     to test endpoints. This should be avalid HTTP(S) URI.

   @option options [Integer] :endpoint_cache_max_entries (1000)
     Used for the maximum size limit of the LRU cache storing endpoints data
     for endpoint discovery enabled operations. Defaults to 1000.

   @option options [Integer] :endpoint_cache_max_threads (10)
     Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

   @option options [Integer] :endpoint_cache_poll_interval (60)
     When :endpoint_discovery and :active_endpoint_cache is enabled,
     Use this option to config the time interval in seconds for making
     requests fetching endpoints information. Defaults to 60 sec.

   @option options [Boolean] :endpoint_discovery (false)
     When set to `true`, endpoint discovery will be enabled for operations when available. Defaults to `false`.

   @option options [Aws::Log::Formatter] :log_formatter (Aws::Log::Formatter.default)
     The log formatter.

   @option options [Symbol] :log_level (:info)
     The log level to send messages to the `:logger` at.

   @option options [Logger] :logger
     The Logger instance to send log messages to.  If this option
     is not set, logging will be disabled.

   @option options [String] :profile ("default")
     Used when loading credentials from the shared credentials file
     at HOME/.aws/credentials.  When not specified, 'default' is used.

   @option options [Float] :retry_base_delay (0.3)
     The base delay in seconds used by the default backoff function.

   @option options [Symbol] :retry_jitter (:none)
     A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number.

     @see https://www.awsarchitectureblog.com/2015/03/backoff.html

   @option options [Integer] :retry_limit (3)
     The maximum number of times to retry failed requests.  Only
     ~ 500 level server errors and certain ~ 400 level client errors
     are retried.  Generally, these are throttling errors, data
     checksum errors, networking errors, timeout errors and auth
     errors from expired credentials.

   @option options [Integer] :retry_max_delay (0)
     The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function.

   @option options [String] :secret_access_key

   @option options [String] :session_token

   @option options [Boolean] :stub_responses (false)
     Causes the client to return stubbed responses. By default
     fake responses are generated and returned. You can specify
     the response data to return or errors to raise by calling
     {ClientStubs#stub_responses}. See {ClientStubs} for more information.

     ** Please note ** When response stubbing is enabled, no HTTP
     requests are made, and retries are disabled.

   @option options [Boolean] :validate_params (true)
     When `true`, request parameters are validated before
     sending the request.

   @option options [URI::HTTP,String] :http_proxy A proxy to send
     requests through.  Formatted like 'http://proxy.com:123'.

   @option options [Float] :http_open_timeout (15) The number of
     seconds to wait when opening a HTTP session before rasing a
     `Timeout::Error`.

   @option options [Integer] :http_read_timeout (60) The default
     number of seconds to wait for response data.  This value can
     safely be set
     per-request on the session yeidled by {#session_for}.

   @option options [Float] :http_idle_timeout (5) The number of
     seconds a connection is allowed to sit idble before it is
     considered stale.  Stale connections are closed and removed
     from the pool before making a request.

   @option options [Float] :http_continue_timeout (1) The number of
     seconds to wait for a 100-continue response before sending the
     request body.  This option has no effect unless the request has
     "Expect" header set to "100-continue".  Defaults to `nil` which
     disables this behaviour.  This value can safely be set per
     request on the session yeidled by {#session_for}.

   @option options [Boolean] :http_wire_trace (false) When `true`,
     HTTP debug output will be sent to the `:logger`.

   @option options [Boolean] :ssl_verify_peer (true) When `true`,
     SSL peer certificates are verified when establishing a
     connection.

   @option options [String] :ssl_ca_bundle Full path to the SSL
     certificate authority bundle file that should be used when
     verifying peer certificates.  If you do not pass
     `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default
     will be used if available.

   @option options [String] :ssl_ca_directory Full path of the
     directory that contains the unbundled SSL certificate
     authority files for verifying peer certificates.  If you do
     not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the the
     system default will be used if available.

 @!group API Operations
 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.

 The `PostContent` operation supports audio input at 8kHz and 16kHz.
 You can use 8kHz audio to achieve higher speech recognition accuracy
 in telephone audio applications.

 In response, Amazon Lex returns the next message to convey to the
 user. Consider the following example messages:

 * 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?".

 * 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?".

 * After the user replies "Yes" to the confirmation prompt, Amazon
   Lex might return a conclusion statement: "Thank you, your cheese
   pizza has been ordered.".

 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
 `message`, 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:

 * If the message is to elicit slot data, Amazon Lex returns the
   following context information:

   * `x-amz-lex-dialog-state` header set to `ElicitSlot`

   * `x-amz-lex-intent-name` header set to the intent name in the
     current context

   * `x-amz-lex-slot-to-elicit` header set to the slot name for which
     the `message` is eliciting information

   * `x-amz-lex-slots` header set to a map of slots configured for the
     intent with their current values

 * If the message is a confirmation prompt, the
   `x-amz-lex-dialog-state` header is set to `Confirmation` and the
   `x-amz-lex-slot-to-elicit` header is omitted.

 * If the message is a clarification prompt configured for the intent,
   indicating that the user intent is not understood, the
   `x-amz-dialog-state` header is set to `ElicitIntent` and the
   `x-amz-slot-to-elicit` header is omitted.

 In addition, Amazon Lex also returns your application-specific
 `sessionAttributes`. For more information, see [Managing Conversation
 Context][1].



 [1]: http://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html

 @option params [required, String] :bot_name
   Name of the Amazon Lex bot.

 @option params [required, String] :bot_alias
   Alias of the Amazon Lex bot.

 @option params [required, String] :user_id
   The ID of the client application user. Amazon Lex uses this to
   identify a user's conversation with your bot. At runtime, each
   request must contain the `userID` field.

   To decide the user ID to use for your application, consider the
   following factors.

   * The `userID` field must not contain any personally identifiable
     information of the user, for example, name, personal identification
     numbers, or other end user personal information.

   * If you want a user to start a conversation on one device and
     continue on another device, use a user-specific identifier.

   * If you want the same user to be able to have two independent
     conversations on two different devices, choose a device-specific
     identifier.

   * A user can't have two independent conversations with two different
     versions of the same bot. For example, a user can't have a
     conversation with the PROD and BETA versions of the same bot. If you
     anticipate that a user will need to have conversation with two
     different versions, for example, while testing, include the bot
     alias in the user ID to separate the two conversations.

 @option params [String] :session_attributes
   You pass this value as the `x-amz-lex-session-attributes` HTTP header.

   Application-specific information passed between Amazon Lex and a
   client application. The value must be a JSON serialized and base64
   encoded map with string keys and values. The total size of the
   `sessionAttributes` and `requestAttributes` headers is limited to 12
   KB.

   For more information, see [Setting Session Attributes][1].

   **SDK automatically handles json encoding and base64 encoding for you
   when the required value (Hash, Array, etc.) is provided according to
   the description.**



   [1]: http://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs

 @option params [String] :request_attributes
   You pass this value as the `x-amz-lex-request-attributes` HTTP header.

   Request-specific information passed between Amazon Lex and a client
   application. The value must be a JSON serialized and base64 encoded
   map with string keys and values. The total size of the
   `requestAttributes` and `sessionAttributes` headers is limited to 12
   KB.

   The namespace `x-amz-lex:` is reserved for special attributes. Don't
   create any request attributes with the prefix `x-amz-lex:`.

   For more information, see [Setting Request Attributes][1].

   **SDK automatically handles json encoding and base64 encoding for you
   when the required value (Hash, Array, etc.) is provided according to
   the description.**



   [1]: http://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs

 @option params [required, String] :content_type
   You pass this value as the `Content-Type` HTTP header.

   Indicates the audio format or text. The header value must start with
   one of the following prefixes:

   * PCM format, audio data must be in little-endian byte order.

     * audio/l16; rate=16000; channels=1

     * audio/x-l16; sample-rate=16000; channel-count=1

     * audio/lpcm; sample-rate=8000; sample-size-bits=16;
       channel-count=1; is-big-endian=false

   * Opus format

     * audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=256000;
       frame-size-milliseconds=4

     ^

   * Text format

     * text/plain; charset=utf-8

     ^

 @option params [String] :accept
   You pass this value as the `Accept` HTTP header.

   The message Amazon Lex returns in the response can be either text or
   speech based on the `Accept` HTTP header value in the request.

   * If the value is `text/plain; charset=utf-8`, Amazon Lex returns text
     in the response.

   * If the value begins with `audio/`, Amazon Lex returns speech in the
     response. Amazon Lex uses Amazon Polly to generate the speech (using
     the configuration you specified in the `Accept` header). For
     example, if you specify `audio/mpeg` as the value, Amazon Lex
     returns speech in the MPEG format.

     The following are the accepted values:

     * audio/mpeg

     * audio/ogg

     * audio/pcm

     * text/plain; charset=utf-8

     * audio/* (defaults to mpeg)

 @option params [required, String, IO] :input_stream
   User input in PCM or Opus audio format or text format as described in
   the `Content-Type` HTTP header.

   You can stream audio data to Amazon Lex or you can create a local
   buffer that captures all of the audio data before sending. In general,
   you get better performance if you stream audio data rather than
   buffering the data locally.

 @return [Types::PostContentResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:

   * {Types::PostContentResponse#content_type #content_type} => String
   * {Types::PostContentResponse#intent_name #intent_name} => String
   * {Types::PostContentResponse#slots #slots} => String
   * {Types::PostContentResponse#session_attributes #session_attributes} => String
   * {Types::PostContentResponse#message #message} => String
   * {Types::PostContentResponse#message_format #message_format} => String
   * {Types::PostContentResponse#dialog_state #dialog_state} => String
   * {Types::PostContentResponse#slot_to_elicit #slot_to_elicit} => String
   * {Types::PostContentResponse#input_transcript #input_transcript} => String
   * {Types::PostContentResponse#audio_stream #audio_stream} => IO

 @example Request syntax with placeholder values

   resp = client.post_content({
     bot_name: "BotName", # required
     bot_alias: "BotAlias", # required
     user_id: "UserId", # required
     session_attributes: "AttributesString",
     request_attributes: "AttributesString",
     content_type: "HttpContentType", # required
     accept: "Accept",
     input_stream: "data", # required
   })

 @example Response structure

   resp.content_type #=> String
   resp.intent_name #=> String
   resp.slots #=> String
   resp.session_attributes #=> String
   resp.message #=> String
   resp.message_format #=> String, one of "PlainText", "CustomPayload", "SSML", "Composite"
   resp.dialog_state #=> String, one of "ElicitIntent", "ConfirmIntent", "ElicitSlot", "Fulfilled", "ReadyForFulfillment", "Failed"
   resp.slot_to_elicit #=> String
   resp.input_transcript #=> String
   resp.audio_stream #=> IO

 @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostContent AWS API Documentation

 @overload post_content(params = {})
 @param [Hash] params ({})