aws-sdk-lexruntimeservice 1.0.0.rc1 → 1.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a68af403e476909b53d65dcd4367610b56b8edf
-  data.tar.gz: e716ca7adac060a4b06fe03dd74d73458f371227
+  metadata.gz: 064ad4c323c89dcdc169a87426b5b0a87476af90
+  data.tar.gz: 71d99d170a6778994ba1f23d73743f4fd27ef39a
 SHA512:
-  metadata.gz: 8ab76ac4c43c1dab2b200d863d50cd8dfa460441c813a1bb32da6d1350c1d66e8f6b67ca97c9eee27d97b216c1f2d06191f7c060d553e3db584356ce318cb055
-  data.tar.gz: 32fbb644e634ebd18710119bb599c094a53e5442060f731d235e580db5ad1e4b88a59571c790f2473d352f4310e2a06f032f2bc7bf67c031bff3d2dc1b795191
+  metadata.gz: 2c37948a0ce4176aa1168c8c1d2687ca989c6ebb82f61389533cf3e294eaaf3e6843b9bbee3fa6bf30240115824bc51e56c13f3f08bbc85b731b092181e56fb1
+  data.tar.gz: ee5751ca966d595d5162a23671082a93cfd302ec60bec49adb187425322339ad086109105cf9f021637659b4482fac30787d55ed557c1c50994f8c10df0ba49d

data/lib/aws-sdk-lexruntimeservice.rb

@@ -42,6 +42,6 @@ require_relative 'aws-sdk-lexruntimeservice/customizations'
 # @service
 module Aws::LexRuntimeService
 
-  GEM_VERSION = '1.0.0.rc1'
+  GEM_VERSION = '1.0.0.rc2'
 
 end

data/lib/aws-sdk-lexruntimeservice/client.rb

@@ -18,6 +18,7 @@ require 'aws-sdk-core/plugins/regional_endpoint.rb'
 require 'aws-sdk-core/plugins/response_paging.rb'
 require 'aws-sdk-core/plugins/stub_responses.rb'
 require 'aws-sdk-core/plugins/idempotency_token.rb'
+require 'aws-sdk-core/plugins/jsonvalue_converter.rb'
 require 'aws-sdk-core/plugins/signature_v4.rb'
 require 'aws-sdk-core/plugins/protocols/rest_json.rb'
 
@@ -45,6 +46,7 @@ module Aws::LexRuntimeService
     add_plugin(Aws::Plugins::ResponsePaging)
     add_plugin(Aws::Plugins::StubResponses)
     add_plugin(Aws::Plugins::IdempotencyToken)
+    add_plugin(Aws::Plugins::JsonvalueConverter)
     add_plugin(Aws::Plugins::SignatureV4)
     add_plugin(Aws::Plugins::Protocols::RestJson)
 
@@ -143,29 +145,63 @@ module Aws::LexRuntimeService
 
     # @!group API Operations
 
-    # Sends user input text to Amazon Lex at runtime. Amazon Lex uses the
-    # machine learning model that the service built for the application to
-    # interpret user input.
+    # Sends user input (text or speech) to Amazon Lex. Clients use this API
+    # to send requests to Amazon Lex at runtime. Amazon Lex interprets the
+    # user input using the machine learning model that it built for the bot.
     #
-    # In response, Amazon Lex returns the next message to convey to the user
-    # (based on the context of the user interaction) and whether to expect a
-    # user response to the message (`dialogState`). For example, consider
-    # the following response messages:
+    # In response, Amazon Lex returns the next message to convey to the
+    # user. Consider the following example messages:
     #
-    # * "What pizza toppings would you like?" – In this case, the
-    #   `dialogState` would be `ElicitSlot` (that is, a user response is
-    #   expected).
+    # * 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?".
     #
-    # * "Your order has been placed." – In this case, Amazon Lex returns
-    #   one of the following `dialogState` values depending on how the
-    #   intent fulfillment is configured (see `fulfillmentActivity` in
-    #   `CreateIntent`):
+    # * 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?".
     #
-    #   * `FulFilled` – The intent fulfillment is configured through a
-    #     Lambda function.
+    # * After the user replies "Yes" to the confirmation prompt, Amazon
+    #   Lex might return a conclusion statement: "Thank you, your cheese
+    #   pizza has been ordered.".
     #
-    #   * `ReadyForFulfilment` – The intent's `fulfillmentActivity` is to
-    #     simply return the intent data back to the client application.
+    # 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.
@@ -174,11 +210,255 @@ module Aws::LexRuntimeService
     #   Alias of the Amazon Lex bot.
     #
     # @option params [required, String] :user_id
-    #   User ID of your client application. Typically, each of your
-    #   application users should have a unique ID. Note the following
-    #   considerations:
+    #   ID of the client application user. Typically, each of your application
+    #   users should have a unique ID. The application developer decides the
+    #   user IDs. At runtime, each request must include the user ID. Note the
+    #   following considerations:
+    #
+    #   * If you want a user to start conversation on one device and continue
+    #     the conversation on another device, you might choose a user-specific
+    #     identifier, such as the user's login, or Amazon Cognito user ID
+    #     (assuming your application is using Amazon Cognito).
+    #
+    #   * If you want the same user to be able to have two independent
+    #     conversations on two different devices, you might choose
+    #     device-specific identifier, such as device ID, or some globally
+    #     unique identifier.
+    #
+    # @option params [String] :session_attributes
+    #   You pass this value in the `x-amz-lex-session-attributes` HTTP header.
+    #   The value must be map (keys and values must be strings) that is JSON
+    #   serialized and then base64 encoded.
+    #
+    #   A session represents dialog between a user and Amazon Lex. At runtime,
+    #   a client application can pass contextual information, in the request
+    #   to Amazon Lex. For example,
+    #
+    #   * You might use session attributes to track the requestID of user
+    #     requests.
+    #
+    #   * In Getting Started Exercise 1, the example bot uses the price
+    #     session attribute to maintain the price of flowers ordered (for
+    #     example, "price":25). The code hook (Lambda function) sets this
+    #     attribute based on the type of flowers ordered. For more
+    #     information, see [Review the Details of Information Flow][1].
+    #
+    #   * In the BookTrip bot exercise, the bot uses the `currentReservation`
+    #     session attribute to maintains the slot data during the in-progress
+    #     conversation to book a hotel or book a car. For more information,
+    #     see [Details of Information Flow][2].
+    #
+    #   Amazon Lex passes these session attributes to the Lambda functions
+    #   configured for the intent In the your Lambda function, you can use the
+    #   session attributes for initialization and customization (prompts).
+    #   Some examples are:
+    #
+    #   * Initialization - In a pizza ordering bot, if you pass user location
+    #     (for example, `"Location : 111 Maple Street"`), then your Lambda
+    #     function might use this information to determine the closest
+    #     pizzeria to place the order (and perhaps set the storeAddress slot
+    #     value as well).
+    #
+    #     Personalized prompts - For example, you can configure prompts to
+    #     refer to the user by name (for example, "Hey \[firstName\], what
+    #     toppings would you like?"). You can pass the user's name as a
+    #     session attribute ("firstName": "Joe") so that Amazon Lex can
+    #     substitute the placeholder to provide a personalized prompt to the
+    #     user ("Hey Joe, what toppings would you like?").
+    #
+    #   <note markdown="1"> Amazon Lex does not persist session attributes.
+    #
+    #    If you configured a code hook for the intent, Amazon Lex passes the
+    #   incoming session attributes to the Lambda function. The Lambda
+    #   function must return these session attributes if you want Amazon Lex
+    #   to return them to the client.
+    #
+    #    If there is no code hook configured for the intent Amazon Lex simply
+    #   returns the session attributes to the client application.
+    #
+    #    </note>
+    #
+    #   **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/gs-bp-details-after-lambda.html
+    #   [2]: http://docs.aws.amazon.com/lex/latest/dg/book-trip-detail-flow.html
+    #
+    # @option params [required, String] :content_type
+    #   You pass this values 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/l16; rate=16000; channels=1
+    #
+    #     * audio/x-l16; sample-rate=16000; channel-count=1
+    #
+    #   * Opus format
+    #
+    #     * audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=1;
+    #       frame-size-milliseconds=1.1
+    #
+    #     ^
+    #
+    #   * 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.
+    #
+    # @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#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: "String",
+    #     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.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 ({})
+    def post_content(params = {}, options = {})
+      req = build_request(:post_content, params)
+      req.send_request(options)
+    end
+
+    # 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.
+    #
+    # In response, Amazon Lex returns the next `message` to convey to the
+    # user an optional `responseCard` to display. 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 obtain user
+    #   confirmation "Proceed with the pizza order?".
+    #
+    # * 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.".
+    #
+    # 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
+    # `message`, 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 `slotToElicit`, `dialogState`, `intentName`, and `slots` fields in
+    # the response. Consider the following examples:
+    #
+    # * If the message is to elicit slot data, Amazon Lex returns the
+    #   following context information:
+    #
+    #   * `dialogState` set to ElicitSlot
+    #
+    #   * `intentName` set to the intent name in the current context
+    #
+    #   * `slotToElicit` set to the slot name for which the `message` is
+    #     eliciting information
+    #
+    #   * `slots` set to a map of slots, configured for the intent, with
+    #     currently known values
+    #
+    # * If the message is a confirmation prompt, the `dialogState` is set to
+    #   ConfirmIntent and `SlotToElicit` is set to null.
+    #
+    # * If the message is a clarification prompt (configured for the intent)
+    #   that indicates that user intent is not understood, the `dialogState`
+    #   is set to ElicitIntent and `slotToElicit` is set to null.
+    #
+    # 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
+    #   The name of the Amazon Lex bot.
+    #
+    # @option params [required, String] :bot_alias
+    #   The alias of the Amazon Lex bot.
+    #
+    # @option params [required, String] :user_id
+    #   The ID of the client application user. The application developer
+    #   decides the user IDs. At runtime, each request must include the user
+    #   ID. Typically, each of your application users should have a unique ID.
+    #   Note the following considerations:
     #
-    #   * If you want a user to start a conversation on one mobile device and
+    #   * If you want a user to start a conversation on one device and
     #     continue the conversation on another device, you might choose a
     #     user-specific identifier, such as a login or Amazon Cognito user ID
     #     (assuming your application is using Amazon Cognito).
@@ -189,44 +469,62 @@ module Aws::LexRuntimeService
     #     unique identifier.
     #
     # @option params [Hash<String,String>] :session_attributes
-    #   A session represents the dialog between a user and Amazon Lex. At
-    #   runtime, a client application can pass contextual information (session
-    #   attributes) in the request. For example, `"FirstName" : "Joe"`. Amazon
-    #   Lex passes these session attributes to the AWS Lambda functions
-    #   configured for the intent (see `dialogCodeHook` and
-    #   `fulfillmentActivity.codeHook` in `CreateIntent`).
-    #
-    #   In your Lambda function, you can use the session attributes for
-    #   customization. Some examples are:
-    #
-    #   * In a pizza ordering application, if you can pass user location as a
-    #     session attribute (for example, `"Location" : "111 Maple street"`),
-    #     your Lambda function might use this information to determine the
-    #     closest pizzeria to place the order.
-    #
-    #   * Use session attributes to personalize prompts. For example, you pass
-    #     in user name as a session attribute (`"FirstName" : "Joe"`), you
-    #     might configure subsequent prompts to refer to this attribute, as
-    #     `$session.FirstName"`. At runtime, Amazon Lex substitutes a real
-    #     value when it generates a prompt, such as "Hello Joe, what would
-    #     you like to order?"
+    #   By using session attributes, a client application can pass contextual
+    #   information in the request to Amazon Lex For example,
+    #
+    #   * In Getting Started Exercise 1, the example bot uses the `price`
+    #     session attribute to maintain the price of the flowers ordered (for
+    #     example, "Price":25). The code hook (the Lambda function) sets
+    #     this attribute based on the type of flowers ordered. For more
+    #     information, see [Review the Details of Information Flow][1].
+    #
+    #   * In the BookTrip bot exercise, the bot uses the `currentReservation`
+    #     session attribute to maintain slot data during the in-progress
+    #     conversation to book a hotel or book a car. For more information,
+    #     see [Details of Information Flow][2].
+    #
+    #   * You might use the session attributes (key, value pairs) to track the
+    #     requestID of user requests.
+    #
+    #   Amazon Lex simply passes these session attributes to the Lambda
+    #   functions configured for the intent.
+    #
+    #   In your Lambda function, you can also use the session attributes for
+    #   initialization and customization (prompts and response cards). Some
+    #   examples are:
+    #
+    #   * Initialization - In a pizza ordering bot, if you can pass the user
+    #     location as a session attribute (for example, `"Location" : "111
+    #     Maple street"`), then your Lambda function might use this
+    #     information to determine the closest pizzeria to place the order
+    #     (perhaps to set the storeAddress slot value).
+    #
+    #   * Personalize prompts - For example, you can configure prompts to
+    #     refer to the user name. (For example, "Hey \[FirstName\], what
+    #     toppings would you like?"). You can pass the user name as a session
+    #     attribute (`"FirstName" : "Joe"`) so that Amazon Lex can substitute
+    #     the placeholder to provide a personalize prompt to the user ("Hey
+    #     Joe, what toppings would you like?").
     #
     #   <note markdown="1"> Amazon Lex does not persist session attributes.
     #
-    #    If the intent is configured without a Lambda function to process the
-    #   intent (that is, the client application to process the intent), Amazon
-    #   Lex simply returns the session attributes back to the client
-    #   application.
+    #    If you configure a code hook for the intent, Amazon Lex passes the
+    #   incoming session attributes to the Lambda function. If you want Amazon
+    #   Lex to return these session attributes back to the client, the Lambda
+    #   function must return them.
     #
-    #    If the intent is configured with a Lambda function to process the
-    #   intent, Amazon Lex passes the incoming session attributes to the
-    #   Lambda function. The Lambda function must return these session
-    #   attributes if you want Amazon Lex to return them back to the client.
+    #    If there is no code hook configured for the intent, Amazon Lex simply
+    #   returns the session attributes back to the client application.
     #
     #    </note>
     #
+    #
+    #
+    #   [1]: http://docs.aws.amazon.com/lex/latest/dg/gs-bp-details-after-lambda.html
+    #   [2]: http://docs.aws.amazon.com/lex/latest/dg/book-trip-detail-flow.html
+    #
     # @option params [required, String] :input_text
-    #   Text user entered (Amazon Lex interprets this text).
+    #   The text that the user entered (Amazon Lex interprets this text).
     #
     # @return [Types::PostTextResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
     #
@@ -293,7 +591,7 @@ module Aws::LexRuntimeService
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-lexruntimeservice'
-      context[:gem_version] = '1.0.0.rc1'
+      context[:gem_version] = '1.0.0.rc2'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/aws-sdk-lexruntimeservice/client_api.rb

@@ -11,8 +11,10 @@ module Aws::LexRuntimeService
 
     include Seahorse::Model
 
+    Accept = Shapes::StringShape.new(name: 'Accept')
     BadGatewayException = Shapes::StructureShape.new(name: 'BadGatewayException')
     BadRequestException = Shapes::StructureShape.new(name: 'BadRequestException')
+    BlobStream = Shapes::BlobShape.new(name: 'BlobStream')
     BotAlias = Shapes::StringShape.new(name: 'BotAlias')
     BotName = Shapes::StringShape.new(name: 'BotName')
     Button = Shapes::StructureShape.new(name: 'Button')
@@ -24,19 +26,25 @@ module Aws::LexRuntimeService
     DialogState = Shapes::StringShape.new(name: 'DialogState')
     ErrorMessage = Shapes::StringShape.new(name: 'ErrorMessage')
     GenericAttachment = Shapes::StructureShape.new(name: 'GenericAttachment')
+    HttpContentType = Shapes::StringShape.new(name: 'HttpContentType')
     IntentName = Shapes::StringShape.new(name: 'IntentName')
     InternalFailureException = Shapes::StructureShape.new(name: 'InternalFailureException')
     LimitExceededException = Shapes::StructureShape.new(name: 'LimitExceededException')
     LoopDetectedException = Shapes::StructureShape.new(name: 'LoopDetectedException')
+    NotAcceptableException = Shapes::StructureShape.new(name: 'NotAcceptableException')
     NotFoundException = Shapes::StructureShape.new(name: 'NotFoundException')
+    PostContentRequest = Shapes::StructureShape.new(name: 'PostContentRequest')
+    PostContentResponse = Shapes::StructureShape.new(name: 'PostContentResponse')
     PostTextRequest = Shapes::StructureShape.new(name: 'PostTextRequest')
     PostTextResponse = Shapes::StructureShape.new(name: 'PostTextResponse')
+    RequestTimeoutException = Shapes::StructureShape.new(name: 'RequestTimeoutException')
     ResponseCard = Shapes::StructureShape.new(name: 'ResponseCard')
     String = Shapes::StringShape.new(name: 'String')
     StringMap = Shapes::MapShape.new(name: 'StringMap')
     StringUrlWithLength = Shapes::StringShape.new(name: 'StringUrlWithLength')
     StringWithLength = Shapes::StringShape.new(name: 'StringWithLength')
     Text = Shapes::StringShape.new(name: 'Text')
+    UnsupportedMediaTypeException = Shapes::StructureShape.new(name: 'UnsupportedMediaTypeException')
     UserId = Shapes::StringShape.new(name: 'UserId')
     genericAttachmentList = Shapes::ListShape.new(name: 'genericAttachmentList')
     listOfButtons = Shapes::ListShape.new(name: 'listOfButtons')
@@ -52,6 +60,30 @@ module Aws::LexRuntimeService
     GenericAttachment.add_member(:buttons, Shapes::ShapeRef.new(shape: listOfButtons, location_name: "buttons"))
     GenericAttachment.struct_class = Types::GenericAttachment
 
+    PostContentRequest.add_member(:bot_name, Shapes::ShapeRef.new(shape: BotName, required: true, location: "uri", location_name: "botName"))
+    PostContentRequest.add_member(:bot_alias, Shapes::ShapeRef.new(shape: BotAlias, required: true, location: "uri", location_name: "botAlias"))
+    PostContentRequest.add_member(:user_id, Shapes::ShapeRef.new(shape: UserId, required: true, location: "uri", location_name: "userId"))
+    PostContentRequest.add_member(:session_attributes, Shapes::ShapeRef.new(shape: String, location: "header", location_name: "x-amz-lex-session-attributes", metadata: {"jsonvalue"=>true}))
+    PostContentRequest.add_member(:content_type, Shapes::ShapeRef.new(shape: HttpContentType, required: true, location: "header", location_name: "Content-Type"))
+    PostContentRequest.add_member(:accept, Shapes::ShapeRef.new(shape: Accept, location: "header", location_name: "Accept"))
+    PostContentRequest.add_member(:input_stream, Shapes::ShapeRef.new(shape: BlobStream, required: true, location_name: "inputStream"))
+    PostContentRequest.struct_class = Types::PostContentRequest
+    PostContentRequest[:payload] = :input_stream
+    PostContentRequest[:payload_member] = PostContentRequest.member(:input_stream)
+
+    PostContentResponse.add_member(:content_type, Shapes::ShapeRef.new(shape: HttpContentType, location: "header", location_name: "Content-Type"))
+    PostContentResponse.add_member(:intent_name, Shapes::ShapeRef.new(shape: IntentName, location: "header", location_name: "x-amz-lex-intent-name"))
+    PostContentResponse.add_member(:slots, Shapes::ShapeRef.new(shape: String, location: "header", location_name: "x-amz-lex-slots", metadata: {"jsonvalue"=>true}))
+    PostContentResponse.add_member(:session_attributes, Shapes::ShapeRef.new(shape: String, location: "header", location_name: "x-amz-lex-session-attributes", metadata: {"jsonvalue"=>true}))
+    PostContentResponse.add_member(:message, Shapes::ShapeRef.new(shape: Text, location: "header", location_name: "x-amz-lex-message"))
+    PostContentResponse.add_member(:dialog_state, Shapes::ShapeRef.new(shape: DialogState, location: "header", location_name: "x-amz-lex-dialog-state"))
+    PostContentResponse.add_member(:slot_to_elicit, Shapes::ShapeRef.new(shape: String, location: "header", location_name: "x-amz-lex-slot-to-elicit"))
+    PostContentResponse.add_member(:input_transcript, Shapes::ShapeRef.new(shape: String, location: "header", location_name: "x-amz-lex-input-transcript"))
+    PostContentResponse.add_member(:audio_stream, Shapes::ShapeRef.new(shape: BlobStream, location_name: "audioStream"))
+    PostContentResponse.struct_class = Types::PostContentResponse
+    PostContentResponse[:payload] = :audio_stream
+    PostContentResponse[:payload_member] = PostContentResponse.member(:audio_stream)
+
     PostTextRequest.add_member(:bot_name, Shapes::ShapeRef.new(shape: BotName, required: true, location: "uri", location_name: "botName"))
     PostTextRequest.add_member(:bot_alias, Shapes::ShapeRef.new(shape: BotAlias, required: true, location: "uri", location_name: "botAlias"))
     PostTextRequest.add_member(:user_id, Shapes::ShapeRef.new(shape: UserId, required: true, location: "uri", location_name: "userId"))
@@ -95,6 +127,26 @@ module Aws::LexRuntimeService
         "signingName" => "lex",
       }
 
+      api.add_operation(:post_content, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "PostContent"
+        o.http_method = "POST"
+        o.http_request_uri = "/bot/{botName}/alias/{botAlias}/user/{userId}/content"
+        o['authtype'] = "v4-unsigned-body"
+        o.input = Shapes::ShapeRef.new(shape: PostContentRequest)
+        o.output = Shapes::ShapeRef.new(shape: PostContentResponse)
+        o.errors << Shapes::ShapeRef.new(shape: NotFoundException)
+        o.errors << Shapes::ShapeRef.new(shape: BadRequestException)
+        o.errors << Shapes::ShapeRef.new(shape: LimitExceededException)
+        o.errors << Shapes::ShapeRef.new(shape: InternalFailureException)
+        o.errors << Shapes::ShapeRef.new(shape: ConflictException)
+        o.errors << Shapes::ShapeRef.new(shape: UnsupportedMediaTypeException)
+        o.errors << Shapes::ShapeRef.new(shape: NotAcceptableException)
+        o.errors << Shapes::ShapeRef.new(shape: RequestTimeoutException)
+        o.errors << Shapes::ShapeRef.new(shape: DependencyFailedException)
+        o.errors << Shapes::ShapeRef.new(shape: BadGatewayException)
+        o.errors << Shapes::ShapeRef.new(shape: LoopDetectedException)
+      end)
+
       api.add_operation(:post_text, Seahorse::Model::Operation.new.tap do |o|
         o.name = "PostText"
         o.http_method = "POST"

data/lib/aws-sdk-lexruntimeservice/types.rb

@@ -12,13 +12,13 @@ module Aws::LexRuntimeService
     # Slack, etc.)
     #
     # @!attribute [rw] text
-    #   Text visible to the user on the button.
+    #   Text that is visible to the user on the button.
     #   @return [String]
     #
     # @!attribute [rw] value
-    #   Value sent to Amazon Lex when user clicks the button. For example,
-    #   consider button text "NYC". When the user clicks the button, the
-    #   value sent can be "New York City".
+    #   The value sent to Amazon Lex when a user chooses the button. For
+    #   example, consider button text "NYC." When the user chooses the
+    #   button, the value sent can be "New York City."
     #   @return [String]
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/Button AWS API Documentation
@@ -33,22 +33,23 @@ module Aws::LexRuntimeService
     # could be an image, a button, a link, or text.
     #
     # @!attribute [rw] title
-    #   Title of the option.
+    #   The title of the option.
     #   @return [String]
     #
     # @!attribute [rw] sub_title
-    #   Subtitle shown below the title.
+    #   The subtitle shown below the title.
     #   @return [String]
     #
     # @!attribute [rw] attachment_link_url
+    #   The URL of an attachment to the response card.
     #   @return [String]
     #
     # @!attribute [rw] image_url
-    #   URL of an image that is displayed to the user.
+    #   The URL of an image that is displayed to the user.
     #   @return [String]
     #
     # @!attribute [rw] buttons
-    #   List of options to show to the user.
+    #   The list of options to show to the user.
     #   @return [Array<Types::Button>]
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/GenericAttachment AWS API Documentation
@@ -62,6 +63,294 @@ module Aws::LexRuntimeService
       include Aws::Structure
     end
 
+    # @note When making an API call, you may pass PostContentRequest
+    #   data as a hash:
+    #
+    #       {
+    #         bot_name: "BotName", # required
+    #         bot_alias: "BotAlias", # required
+    #         user_id: "UserId", # required
+    #         session_attributes: "String",
+    #         content_type: "HttpContentType", # required
+    #         accept: "Accept",
+    #         input_stream: "data", # required
+    #       }
+    #
+    # @!attribute [rw] bot_name
+    #   Name of the Amazon Lex bot.
+    #   @return [String]
+    #
+    # @!attribute [rw] bot_alias
+    #   Alias of the Amazon Lex bot.
+    #   @return [String]
+    #
+    # @!attribute [rw] user_id
+    #   ID of the client application user. Typically, each of your
+    #   application users should have a unique ID. The application developer
+    #   decides the user IDs. At runtime, each request must include the user
+    #   ID. Note the following considerations:
+    #
+    #   * If you want a user to start conversation on one device and
+    #     continue the conversation on another device, you might choose a
+    #     user-specific identifier, such as the user's login, or Amazon
+    #     Cognito user ID (assuming your application is using Amazon
+    #     Cognito).
+    #
+    #   * If you want the same user to be able to have two independent
+    #     conversations on two different devices, you might choose
+    #     device-specific identifier, such as device ID, or some globally
+    #     unique identifier.
+    #   @return [String]
+    #
+    # @!attribute [rw] session_attributes
+    #   You pass this value in the `x-amz-lex-session-attributes` HTTP
+    #   header. The value must be map (keys and values must be strings) that
+    #   is JSON serialized and then base64 encoded.
+    #
+    #   A session represents dialog between a user and Amazon Lex. At
+    #   runtime, a client application can pass contextual information, in
+    #   the request to Amazon Lex. For example,
+    #
+    #   * You might use session attributes to track the requestID of user
+    #     requests.
+    #
+    #   * In Getting Started Exercise 1, the example bot uses the price
+    #     session attribute to maintain the price of flowers ordered (for
+    #     example, "price":25). The code hook (Lambda function) sets this
+    #     attribute based on the type of flowers ordered. For more
+    #     information, see [Review the Details of Information Flow][1].
+    #
+    #   * In the BookTrip bot exercise, the bot uses the
+    #     `currentReservation` session attribute to maintains the slot data
+    #     during the in-progress conversation to book a hotel or book a car.
+    #     For more information, see [Details of Information Flow][2].
+    #
+    #   Amazon Lex passes these session attributes to the Lambda functions
+    #   configured for the intent In the your Lambda function, you can use
+    #   the session attributes for initialization and customization
+    #   (prompts). Some examples are:
+    #
+    #   * Initialization - In a pizza ordering bot, if you pass user
+    #     location (for example, `"Location : 111 Maple Street"`), then your
+    #     Lambda function might use this information to determine the
+    #     closest pizzeria to place the order (and perhaps set the
+    #     storeAddress slot value as well).
+    #
+    #     Personalized prompts - For example, you can configure prompts to
+    #     refer to the user by name (for example, "Hey \[firstName\], what
+    #     toppings would you like?"). You can pass the user's name as a
+    #     session attribute ("firstName": "Joe") so that Amazon Lex can
+    #     substitute the placeholder to provide a personalized prompt to the
+    #     user ("Hey Joe, what toppings would you like?").
+    #
+    #   <note markdown="1"> Amazon Lex does not persist session attributes.
+    #
+    #    If you configured a code hook for the intent, Amazon Lex passes the
+    #   incoming session attributes to the Lambda function. The Lambda
+    #   function must return these session attributes if you want Amazon Lex
+    #   to return them to the client.
+    #
+    #    If there is no code hook configured for the intent Amazon Lex simply
+    #   returns the session attributes to the client application.
+    #
+    #    </note>
+    #
+    #
+    #
+    #   [1]: http://docs.aws.amazon.com/lex/latest/dg/gs-bp-details-after-lambda.html
+    #   [2]: http://docs.aws.amazon.com/lex/latest/dg/book-trip-detail-flow.html
+    #   @return [String]
+    #
+    # @!attribute [rw] content_type
+    #   You pass this values 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/l16; rate=16000; channels=1
+    #
+    #     * audio/x-l16; sample-rate=16000; channel-count=1
+    #
+    #   * Opus format
+    #
+    #     * audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=1;
+    #       frame-size-milliseconds=1.1
+    #
+    #     ^
+    #
+    #   * Text format
+    #
+    #     * text/plain; charset=utf-8
+    #
+    #     ^
+    #   @return [String]
+    #
+    # @!attribute [rw] 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)
+    #   @return [String]
+    #
+    # @!attribute [rw] input_stream
+    #   User input in PCM or Opus audio format or text format as described
+    #   in the `Content-Type` HTTP header.
+    #   @return [IO]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostContentRequest AWS API Documentation
+    #
+    class PostContentRequest < Struct.new(
+      :bot_name,
+      :bot_alias,
+      :user_id,
+      :session_attributes,
+      :content_type,
+      :accept,
+      :input_stream)
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] content_type
+    #   Content type as specified in the `Accept` HTTP header in the
+    #   request.
+    #   @return [String]
+    #
+    # @!attribute [rw] intent_name
+    #   Current user intent that Amazon Lex is aware of.
+    #   @return [String]
+    #
+    # @!attribute [rw] slots
+    #   Map of zero or more intent slots (name/value pairs) Amazon Lex
+    #   detected from the user input during the conversation.
+    #   @return [String]
+    #
+    # @!attribute [rw] session_attributes
+    #   Map of key/value pairs representing the session-specific context
+    #   information.
+    #   @return [String]
+    #
+    # @!attribute [rw] message
+    #   Message to convey to the user. It can come from the bot's
+    #   configuration or a code hook (Lambda function). If the current
+    #   intent is not configured with a code hook or if the code hook
+    #   returned `Delegate` as the `dialogAction.type` in its response, then
+    #   Amazon Lex decides the next course of action and selects an
+    #   appropriate message from the bot configuration based on the current
+    #   user interaction context. For example, if Amazon Lex is not able to
+    #   understand the user input, it uses a clarification prompt message
+    #   (For more information, see the Error Handling section in the Amazon
+    #   Lex console). Another example: if the intent requires confirmation
+    #   before fulfillment, then Amazon Lex uses the confirmation prompt
+    #   message in the intent configuration. If the code hook returns a
+    #   message, Amazon Lex passes it as-is in its response to the client.
+    #   @return [String]
+    #
+    # @!attribute [rw] dialog_state
+    #   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 fullfill
+    #     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.
+    #   @return [String]
+    #
+    # @!attribute [rw] slot_to_elicit
+    #   If the `dialogState` value is `ElicitSlot`, returns the name of the
+    #   slot for which Amazon Lex is eliciting a value.
+    #   @return [String]
+    #
+    # @!attribute [rw] input_transcript
+    #   Transcript of the voice input to the operation.
+    #   @return [String]
+    #
+    # @!attribute [rw] audio_stream
+    #   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.
+    #   @return [IO]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostContentResponse AWS API Documentation
+    #
+    class PostContentResponse < Struct.new(
+      :content_type,
+      :intent_name,
+      :slots,
+      :session_attributes,
+      :message,
+      :dialog_state,
+      :slot_to_elicit,
+      :input_transcript,
+      :audio_stream)
+      include Aws::Structure
+    end
+
     # @note When making an API call, you may pass PostTextRequest
     #   data as a hash:
     #
@@ -76,21 +365,22 @@ module Aws::LexRuntimeService
     #       }
     #
     # @!attribute [rw] bot_name
-    #   Name of the Amazon Lex bot.
+    #   The name of the Amazon Lex bot.
     #   @return [String]
     #
     # @!attribute [rw] bot_alias
-    #   Alias of the Amazon Lex bot.
+    #   The alias of the Amazon Lex bot.
     #   @return [String]
     #
     # @!attribute [rw] user_id
-    #   User ID of your client application. Typically, each of your
-    #   application users should have a unique ID. Note the following
-    #   considerations:
-    #
-    #   * If you want a user to start a conversation on one mobile device
-    #     and continue the conversation on another device, you might choose
-    #     a user-specific identifier, such as a login or Amazon Cognito user
+    #   The ID of the client application user. The application developer
+    #   decides the user IDs. At runtime, each request must include the user
+    #   ID. Typically, each of your application users should have a unique
+    #   ID. Note the following considerations:
+    #
+    #   * If you want a user to start a conversation on one device and
+    #     continue the conversation on another device, you might choose a
+    #     user-specific identifier, such as a login or Amazon Cognito user
     #     ID (assuming your application is using Amazon Cognito).
     #
     #   * If you want the same user to be able to have two independent
@@ -100,45 +390,64 @@ module Aws::LexRuntimeService
     #   @return [String]
     #
     # @!attribute [rw] session_attributes
-    #   A session represents the dialog between a user and Amazon Lex. At
-    #   runtime, a client application can pass contextual information
-    #   (session attributes) in the request. For example, `"FirstName" :
-    #   "Joe"`. Amazon Lex passes these session attributes to the AWS Lambda
-    #   functions configured for the intent (see `dialogCodeHook` and
-    #   `fulfillmentActivity.codeHook` in `CreateIntent`).
-    #
-    #   In your Lambda function, you can use the session attributes for
-    #   customization. Some examples are:
-    #
-    #   * In a pizza ordering application, if you can pass user location as
-    #     a session attribute (for example, `"Location" : "111 Maple
-    #     street"`), your Lambda function might use this information to
-    #     determine the closest pizzeria to place the order.
-    #
-    #   * Use session attributes to personalize prompts. For example, you
-    #     pass in user name as a session attribute (`"FirstName" : "Joe"`),
-    #     you might configure subsequent prompts to refer to this attribute,
-    #     as `$session.FirstName"`. At runtime, Amazon Lex substitutes a
-    #     real value when it generates a prompt, such as "Hello Joe, what
-    #     would you like to order?"
+    #   By using session attributes, a client application can pass
+    #   contextual information in the request to Amazon Lex For example,
+    #
+    #   * In Getting Started Exercise 1, the example bot uses the `price`
+    #     session attribute to maintain the price of the flowers ordered
+    #     (for example, "Price":25). The code hook (the Lambda function)
+    #     sets this attribute based on the type of flowers ordered. For more
+    #     information, see [Review the Details of Information Flow][1].
+    #
+    #   * In the BookTrip bot exercise, the bot uses the
+    #     `currentReservation` session attribute to maintain slot data
+    #     during the in-progress conversation to book a hotel or book a car.
+    #     For more information, see [Details of Information Flow][2].
+    #
+    #   * You might use the session attributes (key, value pairs) to track
+    #     the requestID of user requests.
+    #
+    #   Amazon Lex simply passes these session attributes to the Lambda
+    #   functions configured for the intent.
+    #
+    #   In your Lambda function, you can also use the session attributes for
+    #   initialization and customization (prompts and response cards). Some
+    #   examples are:
+    #
+    #   * Initialization - In a pizza ordering bot, if you can pass the user
+    #     location as a session attribute (for example, `"Location" : "111
+    #     Maple street"`), then your Lambda function might use this
+    #     information to determine the closest pizzeria to place the order
+    #     (perhaps to set the storeAddress slot value).
+    #
+    #   * Personalize prompts - For example, you can configure prompts to
+    #     refer to the user name. (For example, "Hey \[FirstName\], what
+    #     toppings would you like?"). You can pass the user name as a
+    #     session attribute (`"FirstName" : "Joe"`) so that Amazon Lex can
+    #     substitute the placeholder to provide a personalize prompt to the
+    #     user ("Hey Joe, what toppings would you like?").
     #
     #   <note markdown="1"> Amazon Lex does not persist session attributes.
     #
-    #    If the intent is configured without a Lambda function to process the
-    #   intent (that is, the client application to process the intent),
-    #   Amazon Lex simply returns the session attributes back to the client
-    #   application.
+    #    If you configure a code hook for the intent, Amazon Lex passes the
+    #   incoming session attributes to the Lambda function. If you want
+    #   Amazon Lex to return these session attributes back to the client,
+    #   the Lambda function must return them.
     #
-    #    If the intent is configured with a Lambda function to process the
-    #   intent, Amazon Lex passes the incoming session attributes to the
-    #   Lambda function. The Lambda function must return these session
-    #   attributes if you want Amazon Lex to return them back to the client.
+    #    If there is no code hook configured for the intent, Amazon Lex
+    #   simply returns the session attributes back to the client
+    #   application.
     #
     #    </note>
+    #
+    #
+    #
+    #   [1]: http://docs.aws.amazon.com/lex/latest/dg/gs-bp-details-after-lambda.html
+    #   [2]: http://docs.aws.amazon.com/lex/latest/dg/book-trip-detail-flow.html
     #   @return [Hash<String,String>]
     #
     # @!attribute [rw] input_text
-    #   Text user entered (Amazon Lex interprets this text).
+    #   The text that the user entered (Amazon Lex interprets this text).
     #   @return [String]
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostTextRequest AWS API Documentation
@@ -153,96 +462,94 @@ module Aws::LexRuntimeService
     end
 
     # @!attribute [rw] intent_name
-    #   Intent Amazon Lex inferred from the user input text. This is one of
-    #   the intents configured for the bot.
+    #   The current user intent that Amazon Lex is aware of.
     #   @return [String]
     #
     # @!attribute [rw] slots
-    #   Intent slots (name/value pairs) Amazon Lex detected so far from the
-    #   user input in the conversation.
+    #   The intent slots (name/value pairs) that Amazon Lex detected so far
+    #   from the user input in the conversation.
     #   @return [Hash<String,String>]
     #
     # @!attribute [rw] session_attributes
-    #   Map of key value pairs representing the session specific context
+    #   A map of key-value pairs representing the session-specific context
     #   information.
     #   @return [Hash<String,String>]
     #
     # @!attribute [rw] 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.
+    #   A message to convey to the user. It can come from the bot's
+    #   configuration or a code hook (Lambda function). If the current
+    #   intent is not configured with a code hook or the code hook returned
+    #   `Delegate` as the `dialogAction.type` in its response, then Amazon
+    #   Lex decides the next course of action and selects an appropriate
+    #   message from the bot configuration based on the current user
+    #   interaction context. For example, if Amazon Lex is not able to
+    #   understand the user input, it uses a clarification prompt message
+    #   (for more information, see the Error Handling section in the Amazon
+    #   Lex console). Another example: if the intent requires confirmation
+    #   before fulfillment, then Amazon Lex uses the confirmation prompt
+    #   message in the intent configuration. If the code hook returns a
+    #   message, Amazon Lex passes it as-is in its response to the client.
     #   @return [String]
     #
     # @!attribute [rw] dialog_state
-    #   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.
+    #   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.
     #
-    #   * `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.
+    #   * `ElicitIntent` – Amazon Lex wants to elicit user intent.
+    #
+    #     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 dialogState.
+    #
+    #   * `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," a user might respond with
+    #     additional information. For example, "yes, but make it 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 value, or change intent from OrderPizza to
+    #     OrderDrink).
+    #
+    #   * `ElicitSlot` – Amazon Lex is expecting a slot value 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 configured for the
+    #     intent has successfully fulfilled the intent.
+    #
+    #   * `ReadyForFulfillment` – Conveys that the client has to fulfill the
+    #     intent.
+    #
+    #   * `Failed` – Conveys that the conversation with the user failed.
+    #
+    #     This can happen for various reasons including that the user did
+    #     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 the Lambda function failed to fulfill
+    #     the intent.
     #   @return [String]
     #
     # @!attribute [rw] slot_to_elicit
-    #   If `dialogState` value is `ElicitSlot`, returns the name of the slot
-    #   for which Amazon Lex is eliciting a value.
+    #   If the `dialogState` value is `ElicitSlot`, returns the name of the
+    #   slot for which Amazon Lex is eliciting a value.
     #   @return [String]
     #
     # @!attribute [rw] response_card
     #   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.
+    #   prompt. Response Card can come from the bot configuration (in the
+    #   Amazon Lex console, choose the settings button next to a slot) or
+    #   from a code hook (Lambda function).
     #   @return [Types::ResponseCard]
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostTextResponse AWS API Documentation
@@ -259,16 +566,16 @@ module Aws::LexRuntimeService
     end
 
     # If you configure a response card when creating your bots, Amazon Lex
-    # substitutes the session attributes and slot values available, and then
-    # returns it. The response card can also come from a Lambda function (
-    # `dialogCodeHook` and `fulfillmentActivity` on an intent).
+    # substitutes the session attributes and slot values that are available,
+    # and then returns it. The response card can also come from a Lambda
+    # function ( `dialogCodeHook` and `fulfillmentActivity` on an intent).
     #
     # @!attribute [rw] version
-    #   Version of response card format.
+    #   The version of the response card format.
     #   @return [String]
     #
     # @!attribute [rw] content_type
-    #   Content type of the response.
+    #   The content type of the response.
     #   @return [String]
     #
     # @!attribute [rw] generic_attachments

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-lexruntimeservice
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc2
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-07 00:00:00.000000000 Z
+date: 2017-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core