aws-sdk 1.11.3 → 1.12.0

data/lib/aws/core/http/curb_handler.rb

@@ -12,7 +12,6 @@
 # language governing permissions and limitations under the License.
 
 require 'thread'
-require 'stringio'
 
 module AWS
   module Core
@@ -96,11 +95,6 @@ module AWS
           # curl.verbose = true
           request.headers.each {|k, v| curl.headers[k] = v}
 
-          if proxy = request.proxy_uri
-            curl.proxy_url = proxy.to_s
-            curl.proxy_port = proxy.port
-          end
-
           curl.on_header {|header_data|
             if header_data =~ /:\s+/
               name, value = header_data.strip.split(/:\s+/, 2)
@@ -123,7 +117,7 @@ module AWS
             curl.delete = true
           end
 
-          buffer = StringIO.new
+          buffer = []
 
           if read_block
             curl.on_body do |chunk|
@@ -140,8 +134,7 @@ module AWS
           curl.on_complete do
             response.status = curl.response_code
             unless read_block
-              buffer.rewind
-              response.body = buffer.read
+              response.body = buffer.join("")
             end
             thread.run if thread
           end

data/lib/aws/core/http/net_http_handler.rb

@@ -24,12 +24,10 @@ module AWS
       class NetHttpHandler
 
         # @api private
-        PASS_THROUGH_ERRORS = [
-          NoMethodError, FloatDomainError, TypeError, NotImplementedError,
-          SystemExit, Interrupt, SyntaxError, RangeError, NoMemoryError,
-          ArgumentError, ZeroDivisionError, LoadError, NameError,
-          LocalJumpError, SignalException, ScriptError,
-          SystemStackError, RegexpError, IndexError,
+        NETWORK_ERRORS = [
+          SocketError, EOFError, IOError, Timeout::Error,
+          Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE,
+          Errno::EINVAL, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError,
         ]
 
         # (see ConnectionPool.new)
@@ -47,6 +45,8 @@ module AWS
         # @param [Response] response
         # @return [nil]
         def handle request, response, &read_block
+          retry_possible = true
+
           begin
 
             @pool.session_for(request.endpoint) do |http|
@@ -59,7 +59,13 @@ module AWS
                 response.status = net_http_resp.code.to_i
                 response.headers = net_http_resp.to_hash
                 if block_given? and response.status < 300
-                  net_http_resp.read_body(&read_block)
+                  net_http_resp.read_body do |data|
+                    begin
+                      yield data
+                    ensure
+                      retry_possible = false
+                    end
+                  end
                 else
                   response.body = net_http_resp.read_body
                 end
@@ -67,14 +73,8 @@ module AWS
 
             end
 
-          # The first rescue clause is required because Timeout::Error is
-          # a SignalException (in Ruby 1.8, not 1.9).  Generally, SingalExceptions
-          # should not be retried, except for timeout errors.
-          rescue Timeout::Error => error
-            response.network_error = error
-          rescue *PASS_THROUGH_ERRORS => error
-            raise error
-          rescue Exception => error
+          rescue *NETWORK_ERRORS => error
+            raise error unless retry_possible
             response.network_error = error
           end
           nil

data/lib/aws/core/region.rb

@@ -22,18 +22,20 @@ module AWS
     #   aws.dynamo_db.tables.map(&:name)
     #   aws.ec2.instances.map(&:id)
     #
+    # Regions provide helper methods for each service.
+    #
     # @attr_reader [AutoScaling] auto_scaling
     # @attr_reader [CloudFormation] cloud_formation
     # @attr_reader [CloudFront] cloud_front
     # @attr_reader [CloudSearch] cloud_search
     # @attr_reader [CloudWatch] cloud_watch
-    # @attr_reader [DynamoDB] dynamo_db
     # @attr_reader [DataPipeline] data_pipeline
     # @attr_reader [DirectConnect] direct_connect
+    # @attr_reader [DynamoDB] dynamo_db
     # @attr_reader [EC2] ec2
-    # @attr_reader [ElastiCache] elasticache
     # @attr_reader [ElasticBeanstalk] elastic_beanstalk
     # @attr_reader [ElasticTranscoder] elastic_transcoder
+    # @attr_reader [ElastiCache] elasticache
     # @attr_reader [ELB] elb
     # @attr_reader [EMR] emr
     # @attr_reader [Glacier] glacier
@@ -44,13 +46,14 @@ module AWS
     # @attr_reader [Redshift] redshift
     # @attr_reader [Route53] route_53
     # @attr_reader [S3] s3
+    # @attr_reader [SimpleEmailService] ses
     # @attr_reader [SimpleDB] simple_db
-    # @attr_reader [SimpleEmailService] simple_email_service
-    # @attr_reader [SimpleWorkflow] simple_workflow
     # @attr_reader [SNS] sns
     # @attr_reader [SQS] sqs
     # @attr_reader [StorageGateway] storage_gateway
     # @attr_reader [STS] sts
+    # @attr_reader [Support] support
+    # @attr_reader [SimpleWorkflow] swf
     #
     class Region
 
@@ -68,10 +71,11 @@ module AWS
       # @return [Configuration]
       attr_reader :config
 
-      AWS::SERVICES.each_pair do |name,service|
-        define_method(service[:ruby_name]) do
-          AWS.const_get(name).new(:config => config)
+      AWS::SERVICES.values.each do |svc|
+        define_method(svc.method_name) do
+          AWS.const_get(svc.class_name).new(:config => config)
         end
+        alias_method(svc.method_alias, svc.method_name) if svc.method_alias
       end
 
     end

data/lib/aws/dynamo_db/client.rb

@@ -22,43 +22,50 @@ module AWS
       # @!method batch_get_item(options = {})
       # Calls the BatchGetItem API operation.
       # @param [Hash] options
-      #   * `:request_items` - *required* - (Hash<String,Hash>)
-      #     * `:keys` - *required* - (Array<Hash>)
+      #
+      #   * `:request_items` - *required* - (Hash<String,Hash>) A map of one or
+      #     more table names and, for each table, the corresponding primary
+      #     keys for the items to retrieve. Each table name can be invoked only
+      #     once. Each element in the map consists of the following: Keys - An
+      #     array of primary key attribute values that define specific items in
+      #     the table. AttributesToGet - One or more attributes to be retrieved
+      #     from the table or index. By default, all attributes are returned.
+      #     If a specified attribute is not found, it does not appear in the
+      #     result. ConsistentRead - If `true` , a strongly consistent read is
+      #     used; if `false` (the default), an eventually consistent read is
+      #     used.
+      #     * `:keys` - *required* - (Array<Hash>) Represents the primary key
+      #       attribute values that define the items and the attributes
+      #       associated with the items.
       #       * `:hash_key_element` - *required* - (Hash) A hash key element is
       #         treated as the primary key, and can be a string or a number.
       #         Single attribute primary keys have one index value. The value
       #         can be String, Number, StringSet, NumberSet.
-      #         * `:s` - (String) Strings are Unicode with UTF-8 binary
-      #           encoding. The maximum size is limited by the size of the
-      #           primary key (1024 bytes as a range part of a key or 2048
-      #           bytes as a single part hash key) or the item size (64k).
-      #         * `:n` - (String) Numbers are positive or negative exact-value
-      #           decimals and integers. A number can have up to 38 digits
-      #           precision and can be between 10^-128 to 10^+126.
-      #         * `:b` - (String) Binary attributes are sequences of unsigned
-      #           bytes.
-      #         * `:ss` - (Array<String>) A set of strings.
-      #         * `:ns` - (Array<String>) A set of numbers.
-      #         * `:bs` - (Array<String>) A set of binary attributes.
+      #         * `:s` - (String) Represents a String data type
+      #         * `:n` - (String) Represents a Number data type
+      #         * `:b` - (String) Represents a Binary data type
+      #         * `:ss` - (Array<String>) Represents a String set data type
+      #         * `:ns` - (Array<String>) Represents a Number set data type
+      #         * `:bs` - (Array<String>) Represents a Binary set data type
       #       * `:range_key_element` - (Hash) A range key element is treated as
       #         a secondary key (used in conjunction with the primary key), and
       #         can be a string or a number, and is only used for
       #         hash-and-range primary keys. The value can be String, Number,
       #         StringSet, NumberSet.
-      #         * `:s` - (String) Strings are Unicode with UTF-8 binary
-      #           encoding. The maximum size is limited by the size of the
-      #           primary key (1024 bytes as a range part of a key or 2048
-      #           bytes as a single part hash key) or the item size (64k).
-      #         * `:n` - (String) Numbers are positive or negative exact-value
-      #           decimals and integers. A number can have up to 38 digits
-      #           precision and can be between 10^-128 to 10^+126.
-      #         * `:b` - (String) Binary attributes are sequences of unsigned
-      #           bytes.
-      #         * `:ss` - (Array<String>) A set of strings.
-      #         * `:ns` - (Array<String>) A set of numbers.
-      #         * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:attributes_to_get` - (Array<String>)
-      #     * `:consistent_read` - (Boolean)
+      #         * `:s` - (String) Represents a String data type
+      #         * `:n` - (String) Represents a Number data type
+      #         * `:b` - (String) Represents a Binary data type
+      #         * `:ss` - (Array<String>) Represents a String set data type
+      #         * `:ns` - (Array<String>) Represents a Number set data type
+      #         * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:attributes_to_get` - (Array<String>) Represents one or more
+      #       attributes to retrieve from the table or index. If no attribute
+      #       names are specified then all attributes will be returned. If any
+      #       of the specified attributes are not found, they will not appear
+      #       in the result.
+      #     * `:consistent_read` - (Boolean) Represents the consistency of a
+      #       read operation. If set to `true` , then a strongly consistent
+      #       read is used; otherwise, an eventually consistent read is used.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -94,58 +101,68 @@ module AWS
       # @!method batch_write_item(options = {})
       # Calls the BatchWriteItem API operation.
       # @param [Hash] options
+      #
       #   * `:request_items` - *required* - (Hash<String,Array<Hash>>) A map of
-      #     table name to list-of-write-requests. Used as input to the
-      #     BatchWriteItem API call
-      #     * `:put_request` - (Hash)
-      #       * `:item` - *required* - (Hash<String,Hash>) The item to put
-      #         * `:s` - (String) Strings are Unicode with UTF-8 binary
-      #           encoding. The maximum size is limited by the size of the
-      #           primary key (1024 bytes as a range part of a key or 2048
-      #           bytes as a single part hash key) or the item size (64k).
-      #         * `:n` - (String) Numbers are positive or negative exact-value
-      #           decimals and integers. A number can have up to 38 digits
-      #           precision and can be between 10^-128 to 10^+126.
-      #         * `:b` - (String) Binary attributes are sequences of unsigned
-      #           bytes.
-      #         * `:ss` - (Array<String>) A set of strings.
-      #         * `:ns` - (Array<String>) A set of numbers.
-      #         * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:delete_request` - (Hash)
-      #       * `:key` - *required* - (Hash) The item's key to be delete
+      #     one or more table names and, for each table, a list of operations
+      #     to be performed (DeleteRequest or PutRequest). Each element in the
+      #     map consists of the following: DeleteRequest - Perform a DeleteItem
+      #     operation on the specified item. The item to be deleted is
+      #     identified by a Key subelement: Key - A map of primary key
+      #     attribute values that uniquely identify the item. Each entry in
+      #     this map consists of an attribute name and an attribute value.
+      #     PutRequest - Perform a PutItem operation on the specified item. The
+      #     item to be put is identified by an Item subelement: Item - A map of
+      #     attributes and their values. Each entry in this map consists of an
+      #     attribute name and an attribute value. Attribute values must not be
+      #     null; string and binary type attributes must have lengths greater
+      #     than zero; and set type attributes must not be empty. Requests that
+      #     contain empty values will be rejected with a ValidationException.
+      #     If you specify any attributes that are part of an index key, then
+      #     the data types for those attributes must match those of the schema
+      #     in the table's attribute definition.
+      #     * `:put_request` - (Hash) Represents a request to perform a
+      #       DeleteItem operation.
+      #       * `:item` - *required* - (Hash<String,Hash>) A map of attribute
+      #         name to attribute values, representing the primary key of an
+      #         item to be processed by PutItem. All of the table's primary key
+      #         attributes must be specified, and their data types must match
+      #         those of the table's key schema. If any attributes are present
+      #         in the item which are part of an index key schema for the
+      #         table, their types must match the index key schema.
+      #         * `:s` - (String) Represents a String data type
+      #         * `:n` - (String) Represents a Number data type
+      #         * `:b` - (String) Represents a Binary data type
+      #         * `:ss` - (Array<String>) Represents a String set data type
+      #         * `:ns` - (Array<String>) Represents a Number set data type
+      #         * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:delete_request` - (Hash) Represents a request to perform a
+      #       PutItem operation.
+      #       * `:key` - *required* - (Hash) A map of attribute name to
+      #         attribute values, representing the primary key of the item to
+      #         delete. All of the table's primary key attributes must be
+      #         specified, and their data types must match those of the table's
+      #         key schema.
       #         * `:hash_key_element` - *required* - (Hash) A hash key element
       #           is treated as the primary key, and can be a string or a
       #           number. Single attribute primary keys have one index value.
       #           The value can be String, Number, StringSet, NumberSet.
-      #           * `:s` - (String) Strings are Unicode with UTF-8 binary
-      #             encoding. The maximum size is limited by the size of the
-      #             primary key (1024 bytes as a range part of a key or 2048
-      #             bytes as a single part hash key) or the item size (64k).
-      #           * `:n` - (String) Numbers are positive or negative
-      #             exact-value decimals and integers. A number can have up to
-      #             38 digits precision and can be between 10^-128 to 10^+126.
-      #           * `:b` - (String) Binary attributes are sequences of unsigned
-      #             bytes.
-      #           * `:ss` - (Array<String>) A set of strings.
-      #           * `:ns` - (Array<String>) A set of numbers.
-      #           * `:bs` - (Array<String>) A set of binary attributes.
+      #           * `:s` - (String) Represents a String data type
+      #           * `:n` - (String) Represents a Number data type
+      #           * `:b` - (String) Represents a Binary data type
+      #           * `:ss` - (Array<String>) Represents a String set data type
+      #           * `:ns` - (Array<String>) Represents a Number set data type
+      #           * `:bs` - (Array<String>) Represents a Binary set data type
       #         * `:range_key_element` - (Hash) A range key element is treated
       #           as a secondary key (used in conjunction with the primary
       #           key), and can be a string or a number, and is only used for
       #           hash-and-range primary keys. The value can be String, Number,
       #           StringSet, NumberSet.
-      #           * `:s` - (String) Strings are Unicode with UTF-8 binary
-      #             encoding. The maximum size is limited by the size of the
-      #             primary key (1024 bytes as a range part of a key or 2048
-      #             bytes as a single part hash key) or the item size (64k).
-      #           * `:n` - (String) Numbers are positive or negative
-      #             exact-value decimals and integers. A number can have up to
-      #             38 digits precision and can be between 10^-128 to 10^+126.
-      #           * `:b` - (String) Binary attributes are sequences of unsigned
-      #             bytes.
-      #           * `:ss` - (Array<String>) A set of strings.
-      #           * `:ns` - (Array<String>) A set of numbers.
-      #           * `:bs` - (Array<String>) A set of binary attributes.
+      #           * `:s` - (String) Represents a String data type
+      #           * `:n` - (String) Represents a Number data type
+      #           * `:b` - (String) Represents a Binary data type
+      #           * `:ss` - (Array<String>) Represents a String set data type
+      #           * `:ns` - (Array<String>) Represents a Number set data type
+      #           * `:bs` - (Array<String>) Represents a Binary set data type
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -182,16 +199,27 @@ module AWS
       # @!method create_table(options = {})
       # Calls the CreateTable API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table you
-      #     want to create. Allowed characters are a-z, A-Z, 0-9, _
-      #     (underscore), - (hyphen) and . (period).
-      #   * `:key_schema` - *required* - (Hash)
+      #
+      #   * `:table_name` - *required* - (String) The name of the table to
+      #     create.
+      #   * `:key_schema` - *required* - (Hash) Specifies the attributes that
+      #     make up the primary key for the table. The attributes in KeySchema
+      #     must also be defined in the AttributeDefinitions array. For more
+      #     information, see Data Model . Each KeySchemaElement in the array is
+      #     composed of: AttributeName - The name of this key attribute.
+      #     KeyType - Determines whether the key attribute is HASH or RANGE.
+      #     For a primary key that consists of a hash attribute, you must
+      #     specify exactly one element with a KeyType of HASH. For a primary
+      #     key that consists of hash and range attributes, you must specify
+      #     exactly two elements, in this order: The first element must have a
+      #     KeyType of HASH, and the second element must have a KeyType of
+      #     RANGE. For more information, see Specifying the Primary Key .
       #     * `:hash_key_element` - *required* - (Hash) A hash key element is
       #       treated as the primary key, and can be a string or a number.
       #       Single attribute primary keys have one index value. The value can
       #       be String, Number, StringSet, NumberSet.
-      #       * `:attribute_name` - *required* - (String) The AttributeName of
-      #         the KeySchemaElement.
+      #       * `:attribute_name` - *required* - (String) Represents the name
+      #         of a key attribute.
       #       * `:attribute_type` - *required* - (String) The AttributeType of
       #         the KeySchemaElement which can be a String or a Number. Valid
       #         values include:
@@ -203,8 +231,8 @@ module AWS
       #       be a string or a number, and is only used for hash-and-range
       #       primary keys. The value can be String, Number, StringSet,
       #       NumberSet.
-      #       * `:attribute_name` - *required* - (String) The AttributeName of
-      #         the KeySchemaElement.
+      #       * `:attribute_name` - *required* - (String) Represents the name
+      #         of a key attribute.
       #       * `:attribute_type` - *required* - (String) The AttributeType of
       #         the KeySchemaElement which can be a String or a Number. Valid
       #         values include:
@@ -212,15 +240,14 @@ module AWS
       #         * `N`
       #         * `B`
       #   * `:provisioned_throughput` - *required* - (Hash)
-      #     * `:read_capacity_units` - *required* - (Integer) ReadCapacityUnits
-      #       are in terms of strictly consistent reads, assuming items of 1k.
-      #       2k items require twice the ReadCapacityUnits.
-      #       Eventually-consistent reads only require half the
-      #       ReadCapacityUnits of stirctly consistent reads.
-      #     * `:write_capacity_units` - *required* - (Integer)
-      #       WriteCapacityUnits are in terms of strictly consistent reads,
-      #       assuming items of 1k. 2k items require twice the
-      #       WriteCapacityUnits.
+      #     * `:read_capacity_units` - *required* - (Integer) The maximum
+      #       number of strongly consistent reads consumed per second before
+      #       returns a ThrottlingException. For more information, see
+      #       Specifying Read and Write Requirements .
+      #     * `:write_capacity_units` - *required* - (Integer) The maximum
+      #       number of writes consumed per second before returns a
+      #       ThrottlingException. For more information, see Specifying Read
+      #       and Write Requirements .
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -248,61 +275,71 @@ module AWS
       # @!method delete_item(options = {})
       # Calls the DeleteItem API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table in
-      #     which you want to delete an item. Allowed characters are a-z, A-Z,
-      #     0-9, _ (underscore), - (hyphen) and . (period).
-      #   * `:key` - *required* - (Hash)
+      #
+      #   * `:table_name` - *required* - (String) The name of the table from
+      #     which to delete the item.
+      #   * `:key` - *required* - (Hash) A map of attribute names to
+      #     AttributeValue objects, representing the primary key of the item to
+      #     delete.
       #     * `:hash_key_element` - *required* - (Hash) A hash key element is
       #       treated as the primary key, and can be a string or a number.
       #       Single attribute primary keys have one index value. The value can
       #       be String, Number, StringSet, NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       #     * `:range_key_element` - (Hash) A range key element is treated as a
       #       secondary key (used in conjunction with the primary key), and can
       #       be a string or a number, and is only used for hash-and-range
       #       primary keys. The value can be String, Number, StringSet,
       #       NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #   * `:expected` - (Hash<String,Hash>)
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #   * `:expected` - (Hash<String,Hash>) A map of attribute/condition
+      #     pairs. This is the conditional block for the DeleteItemoperation.
+      #     All the conditions must be met for the operation to succeed.
       #     * `:value` - (Hash) Specify whether or not a value already exists
       #       and has a specific content for the attribute name-value pair.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:exists` - (Boolean) Specify whether or not a value already
-      #       exists for the attribute name-value pair.
-      #   * `:return_values` - (String) Valid values include:
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:exists` - (Boolean) Causes to evaluate the value before
+      #       attempting a conditional operation: If Exists is `true` , will
+      #       check to see if that attribute value already exists in the table.
+      #       If it is found, then the operation succeeds. If it is not found,
+      #       the operation fails with a ConditionalCheckFailedException. If
+      #       Exists is `false` , assumes that the attribute value does not
+      #       exist in the table. If in fact the value does not exist, then the
+      #       assumption is valid and the operation succeeds. If the value is
+      #       found, despite the assumption that it does not exist, the
+      #       operation fails with a ConditionalCheckFailedException. The
+      #       default setting for Exists is `true` . If you supply a Value all
+      #       by itself, assumes the attribute exists: You don't have to set
+      #       Exists to `true` , because it is implied. returns a
+      #       ValidationException if: Exists is `true` but there is no Value to
+      #       check. (You expect a value to exist, but don't specify what that
+      #       value is.) Exists is `false` but you also specify a Value. (You
+      #       cannot expect an attribute to have a value, while also expecting
+      #       it not to exist.) If you specify more than one condition for
+      #       Exists, then all of the conditions must evaluate to `true` . (In
+      #       other words, the conditions are ANDed together.) Otherwise, the
+      #       conditional operation will fail.
+      #   * `:return_values` - (String) Use ReturnValues if you want to get the
+      #     item attributes as they appeared before they were deleted. For
+      #     DeleteItem, the valid values are: NONE - If ReturnValues is not
+      #     specified, or if its value is NONE, then nothing is returned. (This
+      #     is the default for ReturnValues.) ALL_OLD - The content of the old
+      #     item is returned. Valid values include:
       #     * `NONE`
       #     * `ALL_OLD`
       #     * `UPDATED_OLD`
@@ -324,9 +361,9 @@ module AWS
       # @!method delete_table(options = {})
       # Calls the DeleteTable API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table you
-      #     want to delete. Allowed characters are a-z, A-Z, 0-9, _
-      #     (underscore), - (hyphen) and . (period).
+      #
+      #   * `:table_name` - *required* - (String) The name of the table to
+      #     delete.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -354,9 +391,9 @@ module AWS
       # @!method describe_table(options = {})
       # Calls the DescribeTable API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table you
-      #     want to describe. Allowed characters are a-z, A-Z, 0-9, _
-      #     (underscore), - (hyphen) and . (period).
+      #
+      #   * `:table_name` - *required* - (String) The name of the table to
+      #     describe.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -384,43 +421,33 @@ module AWS
       # @!method get_item(options = {})
       # Calls the GetItem API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table in
-      #     which you want to get an item. Allowed characters are a-z, A-Z,
-      #     0-9, _ (underscore), - (hyphen) and . (period).
-      #   * `:key` - *required* - (Hash)
+      #
+      #   * `:table_name` - *required* - (String) The name of the table
+      #     containing the requested item.
+      #   * `:key` - *required* - (Hash) A map of attribute names to
+      #     AttributeValue objects, representing the primary key of the item to
+      #     retrieve.
       #     * `:hash_key_element` - *required* - (Hash) A hash key element is
       #       treated as the primary key, and can be a string or a number.
       #       Single attribute primary keys have one index value. The value can
       #       be String, Number, StringSet, NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       #     * `:range_key_element` - (Hash) A range key element is treated as a
       #       secondary key (used in conjunction with the primary key), and can
       #       be a string or a number, and is only used for hash-and-range
       #       primary keys. The value can be String, Number, StringSet,
       #       NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       #   * `:attributes_to_get` - (Array<String>)
       #   * `:consistent_read` - (Boolean)
       # @return [Core::Response]
@@ -439,11 +466,12 @@ module AWS
       # @!method list_tables(options = {})
       # Calls the ListTables API operation.
       # @param [Hash] options
+      #
       #   * `:exclusive_start_table_name` - (String) The name of the table that
       #     starts the list. If you already ran a ListTables operation and
-      #     recieved a LastEvaluatedTableName value in the response, use that
+      #     received a LastEvaluatedTableName value in the response, use that
       #     value here to continue the list.
-      #   * `:limit` - (Integer)
+      #   * `:limit` - (Integer) A maximum number of table names to return.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -454,40 +482,62 @@ module AWS
       # @!method put_item(options = {})
       # Calls the PutItem API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table in
-      #     which you want to put an item. Allowed characters are a-z, A-Z,
-      #     0-9, _ (underscore), - (hyphen) and . (period).
-      #   * `:item` - *required* - (Hash<String,Hash>)
-      #     * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #       The maximum size is limited by the size of the primary key (1024
-      #       bytes as a range part of a key or 2048 bytes as a single part
-      #       hash key) or the item size (64k).
-      #     * `:n` - (String) Numbers are positive or negative exact-value
-      #       decimals and integers. A number can have up to 38 digits
-      #       precision and can be between 10^-128 to 10^+126.
-      #     * `:b` - (String) Binary attributes are sequences of unsigned
-      #       bytes.
-      #     * `:ss` - (Array<String>) A set of strings.
-      #     * `:ns` - (Array<String>) A set of numbers.
-      #     * `:bs` - (Array<String>) A set of binary attributes.
-      #   * `:expected` - (Hash<String,Hash>)
+      #
+      #   * `:table_name` - *required* - (String) The name of the table to
+      #     contain the item.
+      #   * `:item` - *required* - (Hash<String,Hash>) A map of attribute
+      #     name/value pairs, one for each attribute. Only the primary key
+      #     attributes are required; you can optionally provide other attribute
+      #     name-value pairs for the item. If you specify any attributes that
+      #     are part of an index key, then the data types for those attributes
+      #     must match those of the schema in the table's attribute definition.
+      #     For more information about primary keys, see Primary Key . Each
+      #     element in the Item map is an AttributeValue object.
+      #     * `:s` - (String) Represents a String data type
+      #     * `:n` - (String) Represents a Number data type
+      #     * `:b` - (String) Represents a Binary data type
+      #     * `:ss` - (Array<String>) Represents a String set data type
+      #     * `:ns` - (Array<String>) Represents a Number set data type
+      #     * `:bs` - (Array<String>) Represents a Binary set data type
+      #   * `:expected` - (Hash<String,Hash>) A map of attribute/condition
+      #     pairs. This is the conditional block for the PutItem operation. All
+      #     the conditions must be met for the operation to succeed.
       #     * `:value` - (Hash) Specify whether or not a value already exists
       #       and has a specific content for the attribute name-value pair.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:exists` - (Boolean) Specify whether or not a value already
-      #       exists for the attribute name-value pair.
-      #   * `:return_values` - (String) Valid values include:
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:exists` - (Boolean) Causes to evaluate the value before
+      #       attempting a conditional operation: If Exists is `true` , will
+      #       check to see if that attribute value already exists in the table.
+      #       If it is found, then the operation succeeds. If it is not found,
+      #       the operation fails with a ConditionalCheckFailedException. If
+      #       Exists is `false` , assumes that the attribute value does not
+      #       exist in the table. If in fact the value does not exist, then the
+      #       assumption is valid and the operation succeeds. If the value is
+      #       found, despite the assumption that it does not exist, the
+      #       operation fails with a ConditionalCheckFailedException. The
+      #       default setting for Exists is `true` . If you supply a Value all
+      #       by itself, assumes the attribute exists: You don't have to set
+      #       Exists to `true` , because it is implied. returns a
+      #       ValidationException if: Exists is `true` but there is no Value to
+      #       check. (You expect a value to exist, but don't specify what that
+      #       value is.) Exists is `false` but you also specify a Value. (You
+      #       cannot expect an attribute to have a value, while also expecting
+      #       it not to exist.) If you specify more than one condition for
+      #       Exists, then all of the conditions must evaluate to `true` . (In
+      #       other words, the conditions are ANDed together.) Otherwise, the
+      #       conditional operation will fail.
+      #   * `:return_values` - (String) Use ReturnValues if you want to get the
+      #     item attributes as they appeared before they were updated with the
+      #     PutItem request. For PutItem, the valid values are: NONE - If
+      #     ReturnValues is not specified, or if its value is NONE, then
+      #     nothing is returned. (This is the default for ReturnValues.)
+      #     ALL_OLD - If PutItem overwrote an attribute name-value pair, then
+      #     the content of the old item is returned. Valid values include:
       #     * `NONE`
       #     * `ALL_OLD`
       #     * `UPDATED_OLD`
@@ -509,18 +559,14 @@ module AWS
       # @!method query(options = {})
       # Calls the Query API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table in
-      #     which you want to query. Allowed characters are a-z, A-Z, 0-9, _
-      #     (underscore), - (hyphen) and . (period).
-      #   * `:attributes_to_get` - (Array<String>)
-      #   * `:limit` - (Integer) The maximum number of items to return. If
-      #     Amazon DynamoDB hits this limit while querying the table, it stops
-      #     the query and returns the matching values up to the limit, and a
-      #     LastEvaluatedKey to apply in a subsequent operation to continue the
-      #     query. Also, if the result set size exceeds 1MB before Amazon
-      #     DynamoDB hits this limit, it stops the query and returns the
-      #     matching values, and a LastEvaluatedKey to apply in a subsequent
-      #     operation to continue the query.
+      #
+      #   * `:table_name` - *required* - (String) The name of the table
+      #     containing the requested items.
+      #   * `:attributes_to_get` - (Array<String>) You cannot use both
+      #     AttributesToGet and Select together in a Query request, unless the
+      #     value for Select is SPECIFIC_ATTRIBUTES. (This usage is equivalent
+      #     to specifying AttributesToGet without any value for Select.)
+      #   * `:limit` - (Integer)
       #   * `:consistent_read` - (Boolean)
       #   * `:count` - (Boolean) If set to `true` , Amazon DynamoDB returns a
       #     total number of items that match the query parameters, instead of a
@@ -529,35 +575,108 @@ module AWS
       #     Amazon DynamoDB returns a validation error.
       #   * `:hash_key_value` - *required* - (Hash) Attribute value of the hash
       #     component of the composite primary key.
-      #     * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #       The maximum size is limited by the size of the primary key (1024
-      #       bytes as a range part of a key or 2048 bytes as a single part
-      #       hash key) or the item size (64k).
-      #     * `:n` - (String) Numbers are positive or negative exact-value
-      #       decimals and integers. A number can have up to 38 digits
-      #       precision and can be between 10^-128 to 10^+126.
-      #     * `:b` - (String) Binary attributes are sequences of unsigned
-      #       bytes.
-      #     * `:ss` - (Array<String>) A set of strings.
-      #     * `:ns` - (Array<String>) A set of numbers.
-      #     * `:bs` - (Array<String>) A set of binary attributes.
+      #     * `:s` - (String) Represents a String data type
+      #     * `:n` - (String) Represents a Number data type
+      #     * `:b` - (String) Represents a Binary data type
+      #     * `:ss` - (Array<String>) Represents a String set data type
+      #     * `:ns` - (Array<String>) Represents a Number set data type
+      #     * `:bs` - (Array<String>) Represents a Binary set data type
       #   * `:range_key_condition` - (Hash) A container for the attribute
       #     values and comparison operators to use for the query.
-      #     * `:attribute_value_list` - (Array<Hash>)
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:comparison_operator` - *required* - (String) Valid values
-      #       include:
+      #     * `:attribute_value_list` - (Array<Hash>) Represents one or more
+      #       values to evaluate against the supplied attribute. This list
+      #       contains exactly one value, except for a BETWEEN or IN
+      #       comparison, in which case the list contains two values. For type
+      #       Number, value comparisons are numeric. String value comparisons
+      #       for greater than, equals, or less than are based on ASCII
+      #       character code values. For example, a is greater than A, and aa
+      #       is greater than B. For a list of code values, see
+      #       http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
+      #       For Binary, treats each byte of the binary data as unsigned when
+      #       it compares binary values, for example when evaluating query
+      #       expressions.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:comparison_operator` - *required* - (String) Represents a
+      #       comparator for evaluating attributes. For example, equals,
+      #       greater than, less than, etc. For information on specifying data
+      #       types in JSON, see JSON Data Format . The following are
+      #       descriptions of each comparison operator. EQ : Equal.
+      #       AttributeValueList can contain only one AttributeValue of type
+      #       String, Number, or Binary (not a set). If an item contains an
+      #       AttributeValue of a different type than the one specified in the
+      #       request, the value does not match. For example, {"S":"6"} does
+      #       not equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6",
+      #       "2", "1"]}. NE : Not equal. AttributeValueList can contain only
+      #       one AttributeValue of type String, Number, or Binary (not a set).
+      #       If an item contains an AttributeValue of a different type than
+      #       the one specified in the request, the value does not match. For
+      #       example, {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does
+      #       not equal {"NS":["6", "2", "1"]}. LE : Less than or equal.
+      #       AttributeValueList can contain only one AttributeValue of type
+      #       String, Number, or Binary (not a set). If an item contains an
+      #       AttributeValue of a different type than the one specified in the
+      #       request, the value does not match. For example, {"S":"6"} does
+      #       not equal {"N":"6"}. Also, {"N":"6"} does not compare to
+      #       {"NS":["6", "2", "1"]}. LT : Less than. AttributeValueList can
+      #       contain only one AttributeValue of type String, Number, or Binary
+      #       (not a set). If an item contains an AttributeValue of a different
+      #       type than the one specified in the request, the value does not
+      #       match. For example, {"S":"6"} does not equal {"N":"6"}. Also,
+      #       {"N":"6"} does not compare to {"NS":["6", "2", "1"]}. GE :
+      #       Greater than or equal. AttributeValueList can contain only one
+      #       AttributeValue of type String, Number, or Binary (not a set). If
+      #       an item contains an AttributeValue of a different type than the
+      #       one specified in the request, the value does not match. For
+      #       example, {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does
+      #       not compare to {"NS":["6", "2", "1"]}. GT : Greater than.
+      #       AttributeValueList can contain only one AttributeValue of type
+      #       String, Number, or Binary (not a set). If an item contains an
+      #       AttributeValue of a different type than the one specified in the
+      #       request, the value does not match. For example, {"S":"6"} does
+      #       not equal {"N":"6"}. Also, {"N":"6"} does not compare to
+      #       {"NS":["6", "2", "1"]}. NOT_NULL : The attribute exists. NULL :
+      #       The attribute does not exist. CONTAINS : checks for a
+      #       subsequence, or value in a set. AttributeValueList can contain
+      #       only one AttributeValue of type String, Number, or Binary (not a
+      #       set). If the target attribute of the comparison is a String, then
+      #       the operation checks for a substring match. If the target
+      #       attribute of the comparison is Binary, then the operation looks
+      #       for a subsequence of the target that matches the input. If the
+      #       target attribute of the comparison is a set ("SS", "NS", or
+      #       "BS"), then the operation checks for a member of the set (not as
+      #       a substring). NOT_CONTAINS : checks for absence of a subsequence,
+      #       or absence of a value in a set. AttributeValueList can contain
+      #       only one AttributeValue of type String, Number, or Binary (not a
+      #       set). If the target attribute of the comparison is a String, then
+      #       the operation checks for the absence of a substring match. If the
+      #       target attribute of the comparison is Binary, then the operation
+      #       checks for the absence of a subsequence of the target that
+      #       matches the input. If the target attribute of the comparison is a
+      #       set ("SS", "NS", or "BS"), then the operation checks for the
+      #       absence of a member of the set (not as a substring). BEGINS_WITH
+      #       : checks for a prefix. AttributeValueList can contain only one
+      #       AttributeValue of type String or Binary (not a Number or a set).
+      #       The target attribute of the comparison must be a String or Binary
+      #       (not a Number or a set). IN : checks for exact matches.
+      #       AttributeValueList can contain more than one AttributeValue of
+      #       type String, Number, or Binary (not a set). The target attribute
+      #       of the comparison must be of the same type and exact value to
+      #       match. A String never matches a String set. BETWEEN : Greater
+      #       than or equal to the first value, and less than or equal to the
+      #       second value. AttributeValueList must contain two AttributeValue
+      #       elements of the same type, either String, Number, or Binary (not
+      #       a set). A target attribute matches if the target value is greater
+      #       than, or equal to, the first element and less than, or equal to,
+      #       the second element. If an item contains an AttributeValue of a
+      #       different type than the one specified in the request, the value
+      #       does not match. For example, {"S":"6"} does not compare to
+      #       {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2",
+      #       "1"]} Valid values include:
       #       * `EQ`
       #       * `NE`
       #       * `IN`
@@ -571,50 +690,37 @@ module AWS
       #       * `CONTAINS`
       #       * `NOT_CONTAINS`
       #       * `BEGINS_WITH`
-      #   * `:scan_index_forward` - (Boolean) Specifies forward or backward
-      #     traversal of the index. Amazon DynamoDB returns results reflecting
-      #     the requested order, determined by the range key. Default is `true`
-      #     (forward).
-      #   * `:exclusive_start_key` - (Hash) Primary key of the item from which
-      #     to continue an earlier query. An earlier query might provide this
-      #     value as the LastEvaluatedKey if that query operation was
-      #     interrupted before completing the query; either because of the
-      #     result set size or the Limit parameter. The LastEvaluatedKey can be
-      #     passed back in a new query request to continue the operation from
-      #     that point.
+      #   * `:scan_index_forward` - (Boolean) Specifies ascending ( `true` ) or
+      #     descending ( `false` ) traversal of the index. returns results
+      #     reflecting the requested order determined by the range key. If the
+      #     data type is Number, the results are returned in numeric order. For
+      #     String, the results are returned in order of ASCII character code
+      #     values. For Binary, Amazon DynamoDB treats each byte of the binary
+      #     data as unsigned when it compares binary values. If
+      #     ScanIndexForward is not specified, the results are returned in
+      #     ascending order.
+      #   * `:exclusive_start_key` - (Hash)
       #     * `:hash_key_element` - *required* - (Hash) A hash key element is
       #       treated as the primary key, and can be a string or a number.
       #       Single attribute primary keys have one index value. The value can
       #       be String, Number, StringSet, NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       #     * `:range_key_element` - (Hash) A range key element is treated as a
       #       secondary key (used in conjunction with the primary key), and can
       #       be a string or a number, and is only used for hash-and-range
       #       primary keys. The value can be String, Number, StringSet,
       #       NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -647,40 +753,198 @@ module AWS
       # @!method scan(options = {})
       # Calls the Scan API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table in
-      #     which you want to scan. Allowed characters are a-z, A-Z, 0-9, _
-      #     (underscore), - (hyphen) and . (period).
+      #
+      #   * `:table_name` - *required* - (String) The name of the table
+      #     containing the requested items.
       #   * `:attributes_to_get` - (Array<String>)
-      #   * `:limit` - (Integer) The maximum number of items to return. If
-      #     Amazon DynamoDB hits this limit while scanning the table, it stops
-      #     the scan and returns the matching values up to the limit, and a
-      #     LastEvaluatedKey to apply in a subsequent operation to continue the
-      #     scan. Also, if the scanned data set size exceeds 1MB before Amazon
-      #     DynamoDB hits this limit, it stops the scan and returns the
-      #     matching values up to the limit, and a LastEvaluatedKey to apply in
-      #     a subsequent operation to continue the scan.
+      #   * `:limit` - (Integer)
       #   * `:count` - (Boolean) If set to `true` , Amazon DynamoDB returns a
       #     total number of items for the Scan operation, even if the operation
       #     has no matching items for the assigned filter. Do not set Count to
       #     `true` while providing a list of AttributesToGet, otherwise Amazon
       #     DynamoDB returns a validation error.
       #   * `:scan_filter` - (Hash<String,Hash>) Evaluates the scan results and
-      #     returns only the desired values.
-      #     * `:attribute_value_list` - (Array<Hash>)
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:comparison_operator` - *required* - (String) Valid values
-      #       include:
+      #     returns only the desired values. Multiple conditions are treated as
+      #     "AND" operations: all conditions must be met to be included in the
+      #     results. Each ScanConditions element consists of an attribute name
+      #     to compare, along with the following: AttributeValueList - One or
+      #     more values to evaluate against the supplied attribute. This list
+      #     contains exactly one value, except for a BETWEEN or IN comparison,
+      #     in which case the list contains two values. For type Number, value
+      #     comparisons are numeric. String value comparisons for greater than,
+      #     equals, or less than are based on ASCII character code values. For
+      #     example, a is greater than A, and aa is greater than B. For a list
+      #     of code values, see
+      #     http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters. For
+      #     Binary, treats each byte of the binary data as unsigned when it
+      #     compares binary values, for example when evaluating query
+      #     expressions. ComparisonOperator - A comparator for evaluating
+      #     attributes. For example, equals, greater than, less than, etc. For
+      #     information on specifying data types in JSON, see JSON Data Format
+      #     . The following are descriptions of each comparison operator. EQ :
+      #     Equal. AttributeValueList can contain only one AttributeValue of
+      #     type String, Number, or Binary (not a set). If an item contains an
+      #     AttributeValue of a different type than the one specified in the
+      #     request, the value does not match. For example, {"S":"6"} does not
+      #     equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6", "2",
+      #     "1"]}. NE : Not equal. AttributeValueList can contain only one
+      #     AttributeValue of type String, Number, or Binary (not a set). If an
+      #     item contains an AttributeValue of a different type than the one
+      #     specified in the request, the value does not match. For example,
+      #     {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does not equal
+      #     {"NS":["6", "2", "1"]}. LE : Less than or equal. AttributeValueList
+      #     can contain only one AttributeValue of type String, Number, or
+      #     Binary (not a set). If an item contains an AttributeValue of a
+      #     different type than the one specified in the request, the value
+      #     does not match. For example, {"S":"6"} does not equal {"N":"6"}.
+      #     Also, {"N":"6"} does not compare to {"NS":["6", "2", "1"]}. LT :
+      #     Less than. AttributeValueList can contain only one AttributeValue
+      #     of type String, Number, or Binary (not a set). If an item contains
+      #     an AttributeValue of a different type than the one specified in the
+      #     request, the value does not match. For example, {"S":"6"} does not
+      #     equal {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6",
+      #     "2", "1"]}. GE : Greater than or equal. AttributeValueList can
+      #     contain only one AttributeValue of type String, Number, or Binary
+      #     (not a set). If an item contains an AttributeValue of a different
+      #     type than the one specified in the request, the value does not
+      #     match. For example, {"S":"6"} does not equal {"N":"6"}. Also,
+      #     {"N":"6"} does not compare to {"NS":["6", "2", "1"]}. GT : Greater
+      #     than. AttributeValueList can contain only one AttributeValue of
+      #     type String, Number, or Binary (not a set). If an item contains an
+      #     AttributeValue of a different type than the one specified in the
+      #     request, the value does not match. For example, {"S":"6"} does not
+      #     equal {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6",
+      #     "2", "1"]}. NOT_NULL : The attribute exists. NULL : The attribute
+      #     does not exist. CONTAINS : checks for a subsequence, or value in a
+      #     set. AttributeValueList can contain only one AttributeValue of type
+      #     String, Number, or Binary (not a set). If the target attribute of
+      #     the comparison is a String, then the operation checks for a
+      #     substring match. If the target attribute of the comparison is
+      #     Binary, then the operation looks for a subsequence of the target
+      #     that matches the input. If the target attribute of the comparison
+      #     is a set ("SS", "NS", or "BS"), then the operation checks for a
+      #     member of the set (not as a substring). NOT_CONTAINS : checks for
+      #     absence of a subsequence, or absence of a value in a set.
+      #     AttributeValueList can contain only one AttributeValue of type
+      #     String, Number, or Binary (not a set). If the target attribute of
+      #     the comparison is a String, then the operation checks for the
+      #     absence of a substring match. If the target attribute of the
+      #     comparison is Binary, then the operation checks for the absence of
+      #     a subsequence of the target that matches the input. If the target
+      #     attribute of the comparison is a set ("SS", "NS", or "BS"), then
+      #     the operation checks for the absence of a member of the set (not as
+      #     a substring). BEGINS_WITH : checks for a prefix. AttributeValueList
+      #     can contain only one AttributeValue of type String or Binary (not a
+      #     Number or a set). The target attribute of the comparison must be a
+      #     String or Binary (not a Number or a set). IN : checks for exact
+      #     matches. AttributeValueList can contain more than one
+      #     AttributeValue of type String, Number, or Binary (not a set). The
+      #     target attribute of the comparison must be of the same type and
+      #     exact value to match. A String never matches a String set. BETWEEN
+      #     : Greater than or equal to the first value, and less than or equal
+      #     to the second value. AttributeValueList must contain two
+      #     AttributeValue elements of the same type, either String, Number, or
+      #     Binary (not a set). A target attribute matches if the target value
+      #     is greater than, or equal to, the first element and less than, or
+      #     equal to, the second element. If an item contains an AttributeValue
+      #     of a different type than the one specified in the request, the
+      #     value does not match. For example, {"S":"6"} does not compare to
+      #     {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2",
+      #     "1"]}
+      #     * `:attribute_value_list` - (Array<Hash>) Represents one or more
+      #       values to evaluate against the supplied attribute. This list
+      #       contains exactly one value, except for a BETWEEN or IN
+      #       comparison, in which case the list contains two values. For type
+      #       Number, value comparisons are numeric. String value comparisons
+      #       for greater than, equals, or less than are based on ASCII
+      #       character code values. For example, a is greater than A, and aa
+      #       is greater than B. For a list of code values, see
+      #       http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
+      #       For Binary, treats each byte of the binary data as unsigned when
+      #       it compares binary values, for example when evaluating query
+      #       expressions.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:comparison_operator` - *required* - (String) Represents a
+      #       comparator for evaluating attributes. For example, equals,
+      #       greater than, less than, etc. For information on specifying data
+      #       types in JSON, see JSON Data Format . The following are
+      #       descriptions of each comparison operator. EQ : Equal.
+      #       AttributeValueList can contain only one AttributeValue of type
+      #       String, Number, or Binary (not a set). If an item contains an
+      #       AttributeValue of a different type than the one specified in the
+      #       request, the value does not match. For example, {"S":"6"} does
+      #       not equal {"N":"6"}. Also, {"N":"6"} does not equal {"NS":["6",
+      #       "2", "1"]}. NE : Not equal. AttributeValueList can contain only
+      #       one AttributeValue of type String, Number, or Binary (not a set).
+      #       If an item contains an AttributeValue of a different type than
+      #       the one specified in the request, the value does not match. For
+      #       example, {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does
+      #       not equal {"NS":["6", "2", "1"]}. LE : Less than or equal.
+      #       AttributeValueList can contain only one AttributeValue of type
+      #       String, Number, or Binary (not a set). If an item contains an
+      #       AttributeValue of a different type than the one specified in the
+      #       request, the value does not match. For example, {"S":"6"} does
+      #       not equal {"N":"6"}. Also, {"N":"6"} does not compare to
+      #       {"NS":["6", "2", "1"]}. LT : Less than. AttributeValueList can
+      #       contain only one AttributeValue of type String, Number, or Binary
+      #       (not a set). If an item contains an AttributeValue of a different
+      #       type than the one specified in the request, the value does not
+      #       match. For example, {"S":"6"} does not equal {"N":"6"}. Also,
+      #       {"N":"6"} does not compare to {"NS":["6", "2", "1"]}. GE :
+      #       Greater than or equal. AttributeValueList can contain only one
+      #       AttributeValue of type String, Number, or Binary (not a set). If
+      #       an item contains an AttributeValue of a different type than the
+      #       one specified in the request, the value does not match. For
+      #       example, {"S":"6"} does not equal {"N":"6"}. Also, {"N":"6"} does
+      #       not compare to {"NS":["6", "2", "1"]}. GT : Greater than.
+      #       AttributeValueList can contain only one AttributeValue of type
+      #       String, Number, or Binary (not a set). If an item contains an
+      #       AttributeValue of a different type than the one specified in the
+      #       request, the value does not match. For example, {"S":"6"} does
+      #       not equal {"N":"6"}. Also, {"N":"6"} does not compare to
+      #       {"NS":["6", "2", "1"]}. NOT_NULL : The attribute exists. NULL :
+      #       The attribute does not exist. CONTAINS : checks for a
+      #       subsequence, or value in a set. AttributeValueList can contain
+      #       only one AttributeValue of type String, Number, or Binary (not a
+      #       set). If the target attribute of the comparison is a String, then
+      #       the operation checks for a substring match. If the target
+      #       attribute of the comparison is Binary, then the operation looks
+      #       for a subsequence of the target that matches the input. If the
+      #       target attribute of the comparison is a set ("SS", "NS", or
+      #       "BS"), then the operation checks for a member of the set (not as
+      #       a substring). NOT_CONTAINS : checks for absence of a subsequence,
+      #       or absence of a value in a set. AttributeValueList can contain
+      #       only one AttributeValue of type String, Number, or Binary (not a
+      #       set). If the target attribute of the comparison is a String, then
+      #       the operation checks for the absence of a substring match. If the
+      #       target attribute of the comparison is Binary, then the operation
+      #       checks for the absence of a subsequence of the target that
+      #       matches the input. If the target attribute of the comparison is a
+      #       set ("SS", "NS", or "BS"), then the operation checks for the
+      #       absence of a member of the set (not as a substring). BEGINS_WITH
+      #       : checks for a prefix. AttributeValueList can contain only one
+      #       AttributeValue of type String or Binary (not a Number or a set).
+      #       The target attribute of the comparison must be a String or Binary
+      #       (not a Number or a set). IN : checks for exact matches.
+      #       AttributeValueList can contain more than one AttributeValue of
+      #       type String, Number, or Binary (not a set). The target attribute
+      #       of the comparison must be of the same type and exact value to
+      #       match. A String never matches a String set. BETWEEN : Greater
+      #       than or equal to the first value, and less than or equal to the
+      #       second value. AttributeValueList must contain two AttributeValue
+      #       elements of the same type, either String, Number, or Binary (not
+      #       a set). A target attribute matches if the target value is greater
+      #       than, or equal to, the first element and less than, or equal to,
+      #       the second element. If an item contains an AttributeValue of a
+      #       different type than the one specified in the request, the value
+      #       does not match. For example, {"S":"6"} does not compare to
+      #       {"N":"6"}. Also, {"N":"6"} does not compare to {"NS":["6", "2",
+      #       "1"]} Valid values include:
       #       * `EQ`
       #       * `NE`
       #       * `IN`
@@ -694,45 +958,30 @@ module AWS
       #       * `CONTAINS`
       #       * `NOT_CONTAINS`
       #       * `BEGINS_WITH`
-      #   * `:exclusive_start_key` - (Hash) Primary key of the item from which
-      #     to continue an earlier scan. An earlier scan might provide this
-      #     value if that scan operation was interrupted before scanning the
-      #     entire table; either because of the result set size or the Limit
-      #     parameter. The LastEvaluatedKey can be passed back in a new scan
-      #     request to continue the operation from that point.
+      #   * `:exclusive_start_key` - (Hash) In a parallel scan, a Scan request
+      #     that includes ExclusiveStartKey must specify the same segment whose
+      #     previous Scan returned the corresponding value of LastEvaluatedKey.
       #     * `:hash_key_element` - *required* - (Hash) A hash key element is
       #       treated as the primary key, and can be a string or a number.
       #       Single attribute primary keys have one index value. The value can
       #       be String, Number, StringSet, NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       #     * `:range_key_element` - (Hash) A range key element is treated as a
       #       secondary key (used in conjunction with the primary key), and can
       #       be a string or a number, and is only used for hash-and-range
       #       primary keys. The value can be String, Number, StringSet,
       #       NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
@@ -766,79 +1015,197 @@ module AWS
       # @!method update_item(options = {})
       # Calls the UpdateItem API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table in
-      #     which you want to update an item. Allowed characters are a-z, A-Z,
-      #     0-9, _ (underscore), - (hyphen) and . (period).
-      #   * `:key` - *required* - (Hash)
+      #
+      #   * `:table_name` - *required* - (String) The name of the table
+      #     containing the item to update.
+      #   * `:key` - *required* - (Hash) The primary key that defines the item.
+      #     Each element consists of an attribute name and a value for that
+      #     attribute.
       #     * `:hash_key_element` - *required* - (Hash) A hash key element is
       #       treated as the primary key, and can be a string or a number.
       #       Single attribute primary keys have one index value. The value can
       #       be String, Number, StringSet, NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
       #     * `:range_key_element` - (Hash) A range key element is treated as a
       #       secondary key (used in conjunction with the primary key), and can
       #       be a string or a number, and is only used for hash-and-range
       #       primary keys. The value can be String, Number, StringSet,
       #       NumberSet.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #   * `:attribute_updates` - *required* - (Hash<String,Hash>)
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #   * `:attribute_updates` - *required* - (Hash<String,Hash>) The names
+      #     of attributes to be modified, the action to perform on each, and
+      #     the new value for each. If you are updating an attribute that is an
+      #     index key attribute for any indexes on that table, the attribute
+      #     type must match the index key type defined in the
+      #     AttributesDefinition of the table description. You can use
+      #     UpdateItem to update any non-key attributes. Attribute values
+      #     cannot be null. String and binary type attributes must have lengths
+      #     greater than zero. Set type attributes must not be empty. Requests
+      #     with empty values will be rejected with a ValidationException. Each
+      #     AttributeUpdates element consists of an attribute name to modify,
+      #     along with the following: Value - The new value, if applicable, for
+      #     this attribute. Action - Specifies how to perform the update. Valid
+      #     values for Action are PUT, DELETE, and ADD. The behavior depends on
+      #     whether the specified primary key already exists in the table. If
+      #     an item with the specified Key is found in the table: PUT - Adds
+      #     the specified attribute to the item. If the attribute already
+      #     exists, it is replaced by the new value. DELETE - If no value is
+      #     specified, the attribute and its value are removed from the item.
+      #     The data type of the specified value must match the existing
+      #     value's data type. If a set of values is specified, then those
+      #     values are subtracted from the old set. For example, if the
+      #     attribute value was the set [a,b,c] and the DELETE action specified
+      #     [a,c], then the final attribute value would be [b]. Specifying an
+      #     empty set is an error. ADD - If the attribute does not already
+      #     exist, then the attribute and its values are added to the item. If
+      #     the attribute does exist, then the behavior of ADD depends on the
+      #     data type of the attribute: If the existing attribute is a number,
+      #     and if Value is also a number, then the Value is mathematically
+      #     added to the existing attribute. If Value is a negative number,
+      #     then it is subtracted from the existing attribute. If you use ADD
+      #     to increment or decrement a number value for an item that doesn't
+      #     exist before the update, uses 0 as the initial value. In addition,
+      #     if you use ADD to update an existing item, and intend to increment
+      #     or decrement an attribute value which does not yet exist, uses 0 as
+      #     the initial value. For example, suppose that the item you want to
+      #     update does not yet have an attribute named itemcount, but you
+      #     decide to ADD the number 3 to this attribute anyway, even though it
+      #     currently does not exist. will create the itemcount attribute, set
+      #     its initial value to 0, and finally add 3 to it. The result will be
+      #     a new itemcount attribute in the item, with a value of 3. If the
+      #     existing data type is a set, and if the Value is also a set, then
+      #     the Value is added to the existing set. (This is a set operation,
+      #     not mathematical addition.) For example, if the attribute value was
+      #     the set [1,2], and the ADD action specified [3], then the final
+      #     attribute value would be [1,2,3]. An error occurs if an Add action
+      #     is specified for a set attribute and the attribute type specified
+      #     does not match the existing set type. Both sets must have the same
+      #     primitive data type. For example, if the existing data type is a
+      #     set of strings, the Value must also be a set of strings. The same
+      #     holds `true` for number sets and binary sets. This action is only
+      #     valid for an existing attribute whose data type is number or is a
+      #     set. Do not use ADD for any other data types. If no item with the
+      #     specified Key is found: PUT - creates a new item with the specified
+      #     primary key, and then adds the attribute. DELETE - Nothing happens;
+      #     there is no attribute to delete. ADD - creates an item with the
+      #     supplied primary key and number (or set of numbers) for the
+      #     attribute value. The only data types allowed are number and number
+      #     set; no other data types can be specified. If you specify any
+      #     attributes that are part of an index key, then the data types for
+      #     those attributes must match those of the schema in the table's
+      #     attribute definition.
       #     * `:value` - (Hash)
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:action` - (String) Valid values include:
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:action` - (String) Specifies how to perform the update. Valid
+      #       values are PUT, DELETE, and ADD. The behavior depends on whether
+      #       the specified primary key already exists in the table. If an item
+      #       with the specified Key is found in the table: PUT - Adds the
+      #       specified attribute to the item. If the attribute already exists,
+      #       it is replaced by the new value. DELETE - If no value is
+      #       specified, the attribute and its value are removed from the item.
+      #       The data type of the specified value must match the existing
+      #       value's data type. If a set of values is specified, then those
+      #       values are subtracted from the old set. For example, if the
+      #       attribute value was the set [a,b,c] and the DELETE action
+      #       specified [a,c], then the final attribute value would be [b].
+      #       Specifying an empty set is an error. ADD - If the attribute does
+      #       not already exist, then the attribute and its values are added to
+      #       the item. If the attribute does exist, then the behavior of ADD
+      #       depends on the data type of the attribute: If the existing
+      #       attribute is a number, and if Value is also a number, then the
+      #       Value is mathematically added to the existing attribute. If Value
+      #       is a negative number, then it is subtracted from the existing
+      #       attribute. If you use ADD to increment or decrement a number
+      #       value for an item that doesn't exist before the update, uses 0 as
+      #       the initial value. In addition, if you use ADD to update an
+      #       existing item, and intend to increment or decrement an attribute
+      #       value which does not yet exist, uses 0 as the initial value. For
+      #       example, suppose that the item you want to update does not yet
+      #       have an attribute named itemcount, but you decide to ADD the
+      #       number 3 to this attribute anyway, even though it currently does
+      #       not exist. will create the itemcount attribute, set its initial
+      #       value to 0, and finally add 3 to it. The result will be a new
+      #       itemcount attribute in the item, with a value of 3. If the
+      #       existing data type is a set, and if the Value is also a set, then
+      #       the Value is added to the existing set. (This is a set operation,
+      #       not mathematical addition.) For example, if the attribute value
+      #       was the set [1,2], and the ADD action specified [3], then the
+      #       final attribute value would be [1,2,3]. An error occurs if an Add
+      #       action is specified for a set attribute and the attribute type
+      #       specified does not match the existing set type. Both sets must
+      #       have the same primitive data type. For example, if the existing
+      #       data type is a set of strings, the Value must also be a set of
+      #       strings. The same holds `true` for number sets and binary sets.
+      #       This action is only valid for an existing attribute whose data
+      #       type is number or is a set. Do not use ADD for any other data
+      #       types. If no item with the specified Key is found: PUT - creates
+      #       a new item with the specified primary key, and then adds the
+      #       attribute. DELETE - Nothing happens; there is no attribute to
+      #       delete. ADD - creates an item with the supplied primary key and
+      #       number (or set of numbers) for the attribute value. The only data
+      #       types allowed are number and number set; no other data types can
+      #       be specified. Valid values include:
       #       * `ADD`
       #       * `PUT`
       #       * `DELETE`
-      #   * `:expected` - (Hash<String,Hash>)
+      #   * `:expected` - (Hash<String,Hash>) A map of attribute/condition
+      #     pairs. This is the conditional block for the UpdateItem operation.
+      #     All the conditions must be met for the operation to succeed.
       #     * `:value` - (Hash) Specify whether or not a value already exists
       #       and has a specific content for the attribute name-value pair.
-      #       * `:s` - (String) Strings are Unicode with UTF-8 binary encoding.
-      #         The maximum size is limited by the size of the primary key
-      #         (1024 bytes as a range part of a key or 2048 bytes as a single
-      #         part hash key) or the item size (64k).
-      #       * `:n` - (String) Numbers are positive or negative exact-value
-      #         decimals and integers. A number can have up to 38 digits
-      #         precision and can be between 10^-128 to 10^+126.
-      #       * `:b` - (String) Binary attributes are sequences of unsigned
-      #         bytes.
-      #       * `:ss` - (Array<String>) A set of strings.
-      #       * `:ns` - (Array<String>) A set of numbers.
-      #       * `:bs` - (Array<String>) A set of binary attributes.
-      #     * `:exists` - (Boolean) Specify whether or not a value already
-      #       exists for the attribute name-value pair.
-      #   * `:return_values` - (String) Valid values include:
+      #       * `:s` - (String) Represents a String data type
+      #       * `:n` - (String) Represents a Number data type
+      #       * `:b` - (String) Represents a Binary data type
+      #       * `:ss` - (Array<String>) Represents a String set data type
+      #       * `:ns` - (Array<String>) Represents a Number set data type
+      #       * `:bs` - (Array<String>) Represents a Binary set data type
+      #     * `:exists` - (Boolean) Causes to evaluate the value before
+      #       attempting a conditional operation: If Exists is `true` , will
+      #       check to see if that attribute value already exists in the table.
+      #       If it is found, then the operation succeeds. If it is not found,
+      #       the operation fails with a ConditionalCheckFailedException. If
+      #       Exists is `false` , assumes that the attribute value does not
+      #       exist in the table. If in fact the value does not exist, then the
+      #       assumption is valid and the operation succeeds. If the value is
+      #       found, despite the assumption that it does not exist, the
+      #       operation fails with a ConditionalCheckFailedException. The
+      #       default setting for Exists is `true` . If you supply a Value all
+      #       by itself, assumes the attribute exists: You don't have to set
+      #       Exists to `true` , because it is implied. returns a
+      #       ValidationException if: Exists is `true` but there is no Value to
+      #       check. (You expect a value to exist, but don't specify what that
+      #       value is.) Exists is `false` but you also specify a Value. (You
+      #       cannot expect an attribute to have a value, while also expecting
+      #       it not to exist.) If you specify more than one condition for
+      #       Exists, then all of the conditions must evaluate to `true` . (In
+      #       other words, the conditions are ANDed together.) Otherwise, the
+      #       conditional operation will fail.
+      #   * `:return_values` - (String) Use ReturnValues if you want to get the
+      #     item attributes as they appeared either before or after they were
+      #     updated. For UpdateItem, the valid values are: NONE - If
+      #     ReturnValues is not specified, or if its value is NONE, then
+      #     nothing is returned. (This is the default for ReturnValues.)
+      #     ALL_OLD - If UpdateItem overwrote an attribute name-value pair,
+      #     then the content of the old item is returned. UPDATED_OLD - The old
+      #     versions of only the updated attributes are returned. ALL_NEW - All
+      #     of the attributes of the new version of the item are returned.
+      #     UPDATED_NEW - The new versions of only the updated attributes are
+      #     returned. Valid values include:
       #     * `NONE`
       #     * `ALL_OLD`
       #     * `UPDATED_OLD`
@@ -860,19 +1227,18 @@ module AWS
       # @!method update_table(options = {})
       # Calls the UpdateTable API operation.
       # @param [Hash] options
-      #   * `:table_name` - *required* - (String) The name of the table you
-      #     want to update. Allowed characters are a-z, A-Z, 0-9, _
-      #     (underscore), - (hyphen) and . (period).
+      #
+      #   * `:table_name` - *required* - (String) The name of the table to be
+      #     updated.
       #   * `:provisioned_throughput` - *required* - (Hash)
-      #     * `:read_capacity_units` - *required* - (Integer) ReadCapacityUnits
-      #       are in terms of strictly consistent reads, assuming items of 1k.
-      #       2k items require twice the ReadCapacityUnits.
-      #       Eventually-consistent reads only require half the
-      #       ReadCapacityUnits of stirctly consistent reads.
-      #     * `:write_capacity_units` - *required* - (Integer)
-      #       WriteCapacityUnits are in terms of strictly consistent reads,
-      #       assuming items of 1k. 2k items require twice the
-      #       WriteCapacityUnits.
+      #     * `:read_capacity_units` - *required* - (Integer) The maximum
+      #       number of strongly consistent reads consumed per second before
+      #       returns a ThrottlingException. For more information, see
+      #       Specifying Read and Write Requirements .
+      #     * `:write_capacity_units` - *required* - (Integer) The maximum
+      #       number of writes consumed per second before returns a
+      #       ThrottlingException. For more information, see Specifying Read
+      #       and Write Requirements .
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure: