aws-sdk-lexruntimeservice 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2a68af403e476909b53d65dcd4367610b56b8edf
+  data.tar.gz: e716ca7adac060a4b06fe03dd74d73458f371227
+SHA512:
+  metadata.gz: 8ab76ac4c43c1dab2b200d863d50cd8dfa460441c813a1bb32da6d1350c1d66e8f6b67ca97c9eee27d97b216c1f2d06191f7c060d553e3db584356ce318cb055
+  data.tar.gz: 32fbb644e634ebd18710119bb599c094a53e5442060f731d235e580db5ad1e4b88a59571c790f2473d352f4310e2a06f032f2bc7bf67c031bff3d2dc1b795191

data/lib/aws-sdk-lexruntimeservice.rb

@@ -0,0 +1,47 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+require 'aws-sdk-core'
+require 'aws-sigv4'
+
+require_relative 'aws-sdk-lexruntimeservice/types'
+require_relative 'aws-sdk-lexruntimeservice/client_api'
+require_relative 'aws-sdk-lexruntimeservice/client'
+require_relative 'aws-sdk-lexruntimeservice/errors'
+require_relative 'aws-sdk-lexruntimeservice/resource'
+require_relative 'aws-sdk-lexruntimeservice/customizations'
+
+# This module provides support for Amazon Lex Runtime Service. This module is available in the
+# `aws-sdk-lexruntimeservice` gem.
+#
+# # Client
+#
+# The {Client} class provides one method for each API operation. Operation
+# methods each accept a hash of request parameters and return a response
+# structure.
+#
+# See {Client} for more information.
+#
+# # Errors
+#
+# Errors returned from Amazon Lex Runtime Service all
+# extend {Errors::ServiceError}.
+#
+#     begin
+#       # do stuff
+#     rescue Aws::LexRuntimeService::Errors::ServiceError
+#       # rescues all service API errors
+#     end
+#
+# See {Errors} for more information.
+#
+# @service
+module Aws::LexRuntimeService
+
+  GEM_VERSION = '1.0.0.rc1'
+
+end

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

@@ -0,0 +1,318 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+require 'seahorse/client/plugins/content_length.rb'
+require 'aws-sdk-core/plugins/credentials_configuration.rb'
+require 'aws-sdk-core/plugins/logging.rb'
+require 'aws-sdk-core/plugins/param_converter.rb'
+require 'aws-sdk-core/plugins/param_validator.rb'
+require 'aws-sdk-core/plugins/user_agent.rb'
+require 'aws-sdk-core/plugins/helpful_socket_errors.rb'
+require 'aws-sdk-core/plugins/retry_errors.rb'
+require 'aws-sdk-core/plugins/global_configuration.rb'
+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/signature_v4.rb'
+require 'aws-sdk-core/plugins/protocols/rest_json.rb'
+
+Aws::Plugins::GlobalConfiguration.add_identifier(:lexruntimeservice)
+
+module Aws::LexRuntimeService
+  class Client < Seahorse::Client::Base
+
+    include Aws::ClientStubs
+
+    @identifier = :lexruntimeservice
+
+    set_api(ClientApi::API)
+
+    add_plugin(Seahorse::Client::Plugins::ContentLength)
+    add_plugin(Aws::Plugins::CredentialsConfiguration)
+    add_plugin(Aws::Plugins::Logging)
+    add_plugin(Aws::Plugins::ParamConverter)
+    add_plugin(Aws::Plugins::ParamValidator)
+    add_plugin(Aws::Plugins::UserAgent)
+    add_plugin(Aws::Plugins::HelpfulSocketErrors)
+    add_plugin(Aws::Plugins::RetryErrors)
+    add_plugin(Aws::Plugins::GlobalConfiguration)
+    add_plugin(Aws::Plugins::RegionalEndpoint)
+    add_plugin(Aws::Plugins::ResponsePaging)
+    add_plugin(Aws::Plugins::StubResponses)
+    add_plugin(Aws::Plugins::IdempotencyToken)
+    add_plugin(Aws::Plugins::SignatureV4)
+    add_plugin(Aws::Plugins::Protocols::RestJson)
+
+    # @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] :convert_params (true)
+    #   When `true`, an attempt is made to coerce request parameters into
+    #   the required types.
+    #
+    # @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 [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 [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 [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.
+    #
+    def initialize(*args)
+      super
+    end
+
+    # @!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.
+    #
+    # 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:
+    #
+    # * "What pizza toppings would you like?" – In this case, the
+    #   `dialogState` would be `ElicitSlot` (that is, a user response is
+    #   expected).
+    #
+    # * "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`):
+    #
+    #   * `FulFilled` – The intent fulfillment is configured through a
+    #     Lambda function.
+    #
+    #   * `ReadyForFulfilment` – The intent's `fulfillmentActivity` is to
+    #     simply return the intent data back to the client application.
+    #
+    # @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
+    #   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 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 a
+    #     device-specific identifier, such as device ID, or some globally
+    #     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?"
+    #
+    #   <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 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.
+    #
+    #    </note>
+    #
+    # @option params [required, String] :input_text
+    #   Text user entered (Amazon Lex interprets this text).
+    #
+    # @return [Types::PostTextResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::PostTextResponse#intent_name #intent_name} => String
+    #   * {Types::PostTextResponse#slots #slots} => Hash&lt;String,String&gt;
+    #   * {Types::PostTextResponse#session_attributes #session_attributes} => Hash&lt;String,String&gt;
+    #   * {Types::PostTextResponse#message #message} => String
+    #   * {Types::PostTextResponse#dialog_state #dialog_state} => String
+    #   * {Types::PostTextResponse#slot_to_elicit #slot_to_elicit} => String
+    #   * {Types::PostTextResponse#response_card #response_card} => Types::ResponseCard
+    #
+    # @example Request syntax with placeholder values
+    #
+    #   resp = client.post_text({
+    #     bot_name: "BotName", # required
+    #     bot_alias: "BotAlias", # required
+    #     user_id: "UserId", # required
+    #     session_attributes: {
+    #       "String" => "String",
+    #     },
+    #     input_text: "Text", # required
+    #   })
+    #
+    # @example Response structure
+    #
+    #   resp.intent_name #=> String
+    #   resp.slots #=> Hash
+    #   resp.slots["String"] #=> String
+    #   resp.session_attributes #=> Hash
+    #   resp.session_attributes["String"] #=> String
+    #   resp.message #=> String
+    #   resp.dialog_state #=> String, one of "ElicitIntent", "ConfirmIntent", "ElicitSlot", "Fulfilled", "ReadyForFulfillment", "Failed"
+    #   resp.slot_to_elicit #=> String
+    #   resp.response_card.version #=> String
+    #   resp.response_card.content_type #=> String, one of "application/vnd.amazonaws.card.generic"
+    #   resp.response_card.generic_attachments #=> Array
+    #   resp.response_card.generic_attachments[0].title #=> String
+    #   resp.response_card.generic_attachments[0].sub_title #=> String
+    #   resp.response_card.generic_attachments[0].attachment_link_url #=> String
+    #   resp.response_card.generic_attachments[0].image_url #=> String
+    #   resp.response_card.generic_attachments[0].buttons #=> Array
+    #   resp.response_card.generic_attachments[0].buttons[0].text #=> String
+    #   resp.response_card.generic_attachments[0].buttons[0].value #=> String
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostText AWS API Documentation
+    #
+    # @overload post_text(params = {})
+    # @param [Hash] params ({})
+    def post_text(params = {}, options = {})
+      req = build_request(:post_text, params)
+      req.send_request(options)
+    end
+
+    # @!endgroup
+
+    # @param params ({})
+    # @api private
+    def build_request(operation_name, params = {})
+      handlers = @handlers.for(operation_name)
+      context = Seahorse::Client::RequestContext.new(
+        operation_name: operation_name,
+        operation: config.api.operation(operation_name),
+        client: self,
+        params: params,
+        config: config)
+      context[:gem_name] = 'aws-sdk-lexruntimeservice'
+      context[:gem_version] = '1.0.0.rc1'
+      Seahorse::Client::Request.new(handlers, context)
+    end
+
+    # @api private
+    # @deprecated
+    def waiter_names
+      []
+    end
+
+    class << self
+
+      # @api private
+      attr_reader :identifier
+
+      # @api private
+      def errors_module
+        Errors
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::LexRuntimeService
+  # @api private
+  module ClientApi
+
+    include Seahorse::Model
+
+    BadGatewayException = Shapes::StructureShape.new(name: 'BadGatewayException')
+    BadRequestException = Shapes::StructureShape.new(name: 'BadRequestException')
+    BotAlias = Shapes::StringShape.new(name: 'BotAlias')
+    BotName = Shapes::StringShape.new(name: 'BotName')
+    Button = Shapes::StructureShape.new(name: 'Button')
+    ButtonTextStringWithLength = Shapes::StringShape.new(name: 'ButtonTextStringWithLength')
+    ButtonValueStringWithLength = Shapes::StringShape.new(name: 'ButtonValueStringWithLength')
+    ConflictException = Shapes::StructureShape.new(name: 'ConflictException')
+    ContentType = Shapes::StringShape.new(name: 'ContentType')
+    DependencyFailedException = Shapes::StructureShape.new(name: 'DependencyFailedException')
+    DialogState = Shapes::StringShape.new(name: 'DialogState')
+    ErrorMessage = Shapes::StringShape.new(name: 'ErrorMessage')
+    GenericAttachment = Shapes::StructureShape.new(name: 'GenericAttachment')
+    IntentName = Shapes::StringShape.new(name: 'IntentName')
+    InternalFailureException = Shapes::StructureShape.new(name: 'InternalFailureException')
+    LimitExceededException = Shapes::StructureShape.new(name: 'LimitExceededException')
+    LoopDetectedException = Shapes::StructureShape.new(name: 'LoopDetectedException')
+    NotFoundException = Shapes::StructureShape.new(name: 'NotFoundException')
+    PostTextRequest = Shapes::StructureShape.new(name: 'PostTextRequest')
+    PostTextResponse = Shapes::StructureShape.new(name: 'PostTextResponse')
+    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')
+    UserId = Shapes::StringShape.new(name: 'UserId')
+    genericAttachmentList = Shapes::ListShape.new(name: 'genericAttachmentList')
+    listOfButtons = Shapes::ListShape.new(name: 'listOfButtons')
+
+    Button.add_member(:text, Shapes::ShapeRef.new(shape: ButtonTextStringWithLength, required: true, location_name: "text"))
+    Button.add_member(:value, Shapes::ShapeRef.new(shape: ButtonValueStringWithLength, required: true, location_name: "value"))
+    Button.struct_class = Types::Button
+
+    GenericAttachment.add_member(:title, Shapes::ShapeRef.new(shape: StringWithLength, location_name: "title"))
+    GenericAttachment.add_member(:sub_title, Shapes::ShapeRef.new(shape: StringWithLength, location_name: "subTitle"))
+    GenericAttachment.add_member(:attachment_link_url, Shapes::ShapeRef.new(shape: StringUrlWithLength, location_name: "attachmentLinkUrl"))
+    GenericAttachment.add_member(:image_url, Shapes::ShapeRef.new(shape: StringUrlWithLength, location_name: "imageUrl"))
+    GenericAttachment.add_member(:buttons, Shapes::ShapeRef.new(shape: listOfButtons, location_name: "buttons"))
+    GenericAttachment.struct_class = Types::GenericAttachment
+
+    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"))
+    PostTextRequest.add_member(:session_attributes, Shapes::ShapeRef.new(shape: StringMap, location_name: "sessionAttributes"))
+    PostTextRequest.add_member(:input_text, Shapes::ShapeRef.new(shape: Text, required: true, location_name: "inputText"))
+    PostTextRequest.struct_class = Types::PostTextRequest
+
+    PostTextResponse.add_member(:intent_name, Shapes::ShapeRef.new(shape: IntentName, location_name: "intentName"))
+    PostTextResponse.add_member(:slots, Shapes::ShapeRef.new(shape: StringMap, location_name: "slots"))
+    PostTextResponse.add_member(:session_attributes, Shapes::ShapeRef.new(shape: StringMap, location_name: "sessionAttributes"))
+    PostTextResponse.add_member(:message, Shapes::ShapeRef.new(shape: Text, location_name: "message"))
+    PostTextResponse.add_member(:dialog_state, Shapes::ShapeRef.new(shape: DialogState, location_name: "dialogState"))
+    PostTextResponse.add_member(:slot_to_elicit, Shapes::ShapeRef.new(shape: String, location_name: "slotToElicit"))
+    PostTextResponse.add_member(:response_card, Shapes::ShapeRef.new(shape: ResponseCard, location_name: "responseCard"))
+    PostTextResponse.struct_class = Types::PostTextResponse
+
+    ResponseCard.add_member(:version, Shapes::ShapeRef.new(shape: String, location_name: "version"))
+    ResponseCard.add_member(:content_type, Shapes::ShapeRef.new(shape: ContentType, location_name: "contentType"))
+    ResponseCard.add_member(:generic_attachments, Shapes::ShapeRef.new(shape: genericAttachmentList, location_name: "genericAttachments"))
+    ResponseCard.struct_class = Types::ResponseCard
+
+    StringMap.key = Shapes::ShapeRef.new(shape: String)
+    StringMap.value = Shapes::ShapeRef.new(shape: String)
+
+    genericAttachmentList.member = Shapes::ShapeRef.new(shape: GenericAttachment)
+
+    listOfButtons.member = Shapes::ShapeRef.new(shape: Button)
+
+
+    # @api private
+    API = Seahorse::Model::Api.new.tap do |api|
+
+      api.version = "2016-11-28"
+
+      api.metadata = {
+        "endpointPrefix" => "runtime.lex",
+        "jsonVersion" => "1.1",
+        "protocol" => "rest-json",
+        "serviceFullName" => "Amazon Lex Runtime Service",
+        "signatureVersion" => "v4",
+        "signingName" => "lex",
+      }
+
+      api.add_operation(:post_text, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "PostText"
+        o.http_method = "POST"
+        o.http_request_uri = "/bot/{botName}/alias/{botAlias}/user/{userId}/text"
+        o.input = Shapes::ShapeRef.new(shape: PostTextRequest)
+        o.output = Shapes::ShapeRef.new(shape: PostTextResponse)
+        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: DependencyFailedException)
+        o.errors << Shapes::ShapeRef.new(shape: BadGatewayException)
+        o.errors << Shapes::ShapeRef.new(shape: LoopDetectedException)
+      end)
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::LexRuntimeService
+  module Errors
+
+    extend Aws::Errors::DynamicErrors
+
+  end
+end

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

@@ -0,0 +1,23 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::LexRuntimeService
+  class Resource
+
+    # @param options ({})
+    # @option options [Client] :client
+    def initialize(options = {})
+      @client = options[:client] || Client.new(options)
+    end
+
+    # @return [Client]
+    def client
+      @client
+    end
+
+  end
+end

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

@@ -0,0 +1,288 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing guide for more information:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws::LexRuntimeService
+  module Types
+
+    # Represents an option to be shown on the client platform (Facebook,
+    # Slack, etc.)
+    #
+    # @!attribute [rw] text
+    #   Text 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".
+    #   @return [String]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/Button AWS API Documentation
+    #
+    class Button < Struct.new(
+      :text,
+      :value)
+      include Aws::Structure
+    end
+
+    # Represents an option rendered to the user when a prompt is shown. It
+    # could be an image, a button, a link, or text.
+    #
+    # @!attribute [rw] title
+    #   Title of the option.
+    #   @return [String]
+    #
+    # @!attribute [rw] sub_title
+    #   Subtitle shown below the title.
+    #   @return [String]
+    #
+    # @!attribute [rw] attachment_link_url
+    #   @return [String]
+    #
+    # @!attribute [rw] image_url
+    #   URL of an image that is displayed to the user.
+    #   @return [String]
+    #
+    # @!attribute [rw] buttons
+    #   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
+    #
+    class GenericAttachment < Struct.new(
+      :title,
+      :sub_title,
+      :attachment_link_url,
+      :image_url,
+      :buttons)
+      include Aws::Structure
+    end
+
+    # @note When making an API call, you may pass PostTextRequest
+    #   data as a hash:
+    #
+    #       {
+    #         bot_name: "BotName", # required
+    #         bot_alias: "BotAlias", # required
+    #         user_id: "UserId", # required
+    #         session_attributes: {
+    #           "String" => "String",
+    #         },
+    #         input_text: "Text", # 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
+    #   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
+    #     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 a
+    #     device-specific identifier, such as device ID, or some globally
+    #     unique identifier.
+    #   @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?"
+    #
+    #   <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 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.
+    #
+    #    </note>
+    #   @return [Hash<String,String>]
+    #
+    # @!attribute [rw] input_text
+    #   Text 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
+    #
+    class PostTextRequest < Struct.new(
+      :bot_name,
+      :bot_alias,
+      :user_id,
+      :session_attributes,
+      :input_text)
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] intent_name
+    #   Intent Amazon Lex inferred from the user input text. This is one of
+    #   the intents configured for the bot.
+    #   @return [String]
+    #
+    # @!attribute [rw] slots
+    #   Intent slots (name/value pairs) 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
+    #   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.
+    #   @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.
+    #
+    #   * `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.
+    #   @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.
+    #   @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.
+    #   @return [Types::ResponseCard]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/PostTextResponse AWS API Documentation
+    #
+    class PostTextResponse < Struct.new(
+      :intent_name,
+      :slots,
+      :session_attributes,
+      :message,
+      :dialog_state,
+      :slot_to_elicit,
+      :response_card)
+      include Aws::Structure
+    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).
+    #
+    # @!attribute [rw] version
+    #   Version of response card format.
+    #   @return [String]
+    #
+    # @!attribute [rw] content_type
+    #   Content type of the response.
+    #   @return [String]
+    #
+    # @!attribute [rw] generic_attachments
+    #   An array of attachment objects representing options.
+    #   @return [Array<Types::GenericAttachment>]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/runtime.lex-2016-11-28/ResponseCard AWS API Documentation
+    #
+    class ResponseCard < Struct.new(
+      :version,
+      :content_type,
+      :generic_attachments)
+      include Aws::Structure
+    end
+
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: aws-sdk-lexruntimeservice
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Amazon Web Services
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: aws-sigv4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Official AWS Ruby gem for Amazon Lex Runtime Service. This gem is part
+  of the AWS SDK for Ruby.
+email:
+- trevrowe@amazon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aws-sdk-lexruntimeservice.rb
+- lib/aws-sdk-lexruntimeservice/client.rb
+- lib/aws-sdk-lexruntimeservice/client_api.rb
+- lib/aws-sdk-lexruntimeservice/customizations.rb
+- lib/aws-sdk-lexruntimeservice/errors.rb
+- lib/aws-sdk-lexruntimeservice/resource.rb
+- lib/aws-sdk-lexruntimeservice/types.rb
+homepage: http://github.com/aws/aws-sdk-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: AWS SDK for Ruby - Amazon Lex Runtime Service
+test_files: []