aws-sdk 1.8.5 → 1.9.0

data/lib/aws/dynamo_db/attribute_collection.rb

@@ -80,9 +80,9 @@ module AWS
       # Behaves like Hash#each; yields each attribute as a name/value
       # pair.
       #
-      #   attributes.each { |(name, value)| puts "#{name} = #{value}" }
+      #     attributes.each { |(name, value)| puts "#{name} = #{value}" }
       #
-      #   attributes.each { |name, value| puts "#{name} = #{value}" }
+      #     attributes.each { |name, value| puts "#{name} = #{value}" }
       #
       # @param (see #to_hash)
       #
@@ -164,17 +164,16 @@ module AWS
       # attribute is a number, the original value is incremented by
       # the numeric value provided to this method.  For example:
       #
-      #   item = table.items.put(
-      #     :id => "abc123",
-      #     :colors => ["red", "white"],
-      #     :age => 3
-      #   )
-      #   item.attributes.add(
-      #     { :colors => ["muave"],
-      #       :age => 1 },
-      #     :return => :updated_new
-      #   ) # => { "colors" => Set["red", "white", "mauve"],
-      #     #      "age" => 4 }
+      #     item = table.items.put(
+      #       :id => "abc123",
+      #       :colors => ["red", "white"],
+      #       :age => 3
+      #     )
+      #     item.attributes.add(
+      #       { :colors => ["muave"],
+      #         :age => 1 },
+      #       :return => :updated_new
+      #     ) # => { "colors" => Set["red", "white", "mauve"], "age" => 4 }
       #
       # @param [Hash] attributes The attribute values to add.  The
       #   keys of the hash may be strings or symbols.  The values may
@@ -309,20 +308,20 @@ module AWS
       # sequence, and it also allows you to group different kinds of
       # updates into an atomic operation.
       #
-      #   item.attributes.update do |u|
+      #     item.attributes.update do |u|
       #
-      #     # add 12 to the (numeric) value of "views"
-      #     u.add(:views => 12)
+      #       # add 12 to the (numeric) value of "views"
+      #       u.add(:views => 12)
       #
-      #     # delete attributes
-      #     u.delete(:foo, :bar)
+      #       # delete attributes
+      #       u.delete(:foo, :bar)
       #
-      #     # delete values out of a set attribute
-      #     u.delete(:colors => ["red", "blue"])
+      #       # delete values out of a set attribute
+      #       u.delete(:colors => ["red", "blue"])
       #
-      #     # replace values
-      #     u.set(:title => "More Automobiles")
-      #   end
+      #       # replace values
+      #       u.set(:title => "More Automobiles")
+      #     end
       #
       # @param [Hash] options Options for updating the item.
       #
@@ -330,47 +329,43 @@ module AWS
       #   The operation will fail unless the item exists and has the
       #   attributes in the value for this option.  For example:
       #
-      #     # throws DynamoDB::Errors::ConditionalCheckFailedException
-      #     # unless the item has "color" set to "red"
-      #     item.attributes.update(:if => { :color => "red" }) do |u|
-      #       # ...
-      #     end
+      #       # throws DynamoDB::Errors::ConditionalCheckFailedException
+      #       # unless the item has "color" set to "red"
+      #       item.attributes.update(:if => { :color => "red" }) do |u|
+      #         # ...
+      #       end
       #
       # @option options [String, Symbol, Array] :unless_exists A name
       #   or collection of attribute names; if the item already exists
       #   and has a value for any of these attributes, this method
       #   will raise
-      #   +DynamoDB::Errors::ConditionalCheckFailedException+.  For example:
+      #   `DynamoDB::Errors::ConditionalCheckFailedException`.  For example:
       #
-      #     item.attributes.update(:unless_exists => :color) do |u|
-      #       # ...
-      #     end
+      #       item.attributes.update(:unless_exists => :color) do |u|
+      #         # ...
+      #       end
       #
-      # @option options [Symbol] :return (+:none+) Changes the return
+      # @option options [Symbol] :return (`:none`) Changes the return
       #   value of the method.  Valid values:
       #
-      #   [+:none+] Return +nil+
-      #
-      #   [+:all_old+] Returns a hash containing all of the original
-      #                values of the attributes before the update, or
-      #                +nil+ if the item did not exist at the time of
-      #                the update.
-      #
-      #   [+:updated_old+] Returns a hash containing the original
-      #                    values of the attributes that were modified
-      #                    as part of this operation.  This includes
-      #                    attributes that were deleted, and
-      #                    set-valued attributes whose member values
-      #                    were deleted.
-      #
-      #   [+:updated_new+] Returns a hash containing the new values of
-      #                    the attributes that were modified as part
-      #                    of this operation.  This includes
-      #                    set-valued attributes whose member values
-      #                    were deleted.
-      #
-      #   [+:all_new+] Returns a hash containing the new values of all
-      #                of the attributes.
+      #     * `:none` - Return `nil`
+      #     * `:all_old` - Returns a hash containing all of the original
+      #       values of the attributes before the update, or
+      #       `nil` if the item did not exist at the time of
+      #       the update.
+      #     * `:updated_old` - Returns a hash containing the original
+      #       values of the attributes that were modified
+      #       as part of this operation.  This includes
+      #       attributes that were deleted, and
+      #       set-valued attributes whose member values
+      #       were deleted.
+      #     * `:updated_new` - Returns a hash containing the new values of
+      #       the attributes that were modified as part
+      #       of this operation.  This includes
+      #       set-valued attributes whose member values
+      #       were deleted.
+      #     * `:all_new` - Returns a hash containing the new values of all
+      #       of the attributes.
       #
       # @yieldparam [UpdateBuilder] builder A handle for describing
       #   the update.
@@ -379,7 +374,7 @@ module AWS
       #   single operation.  This method will raise an ArgumentError
       #   if multiple updates are described for a single attribute.
       #
-      # @return [nil] See the documentation for the +:return+ option
+      # @return [nil] See the documentation for the `:return` option
       #   above.
       def update(options = {})
         builder = UpdateBuilder.new
@@ -393,7 +388,7 @@ module AWS
       # @param [Array<String, Symbol>] attributes The names of the
       #   attributes to retrieve.  The last argument may be a hash of
       #   options for retrieving attributes from the item.  Currently
-      #   the only supported option is +:consistent_read+; If set to
+      #   the only supported option is `:consistent_read`; If set to
       #   true, then a consistent read is issued, otherwise an
       #   eventually consistent read is used.
       #
@@ -401,7 +396,7 @@ module AWS
       #   value of the attribute at that index in the argument list.
       #   Values may be Strings, BigDecimals, Sets of Strings or Sets
       #   or BigDecimals.  If a requested attribute does not exist,
-      #   the corresponding member of the output array will be +nil+.
+      #   the corresponding member of the output array will be `nil`.
       def values_at(*attributes)
         options = {}
         options = attributes.pop if attributes.last.kind_of?(Hash)

data/lib/aws/dynamo_db/batch_get.rb

@@ -38,33 +38,33 @@ module AWS
       #
       # @param [Symbol, String, Array<String>] attributes The list of attributes
       #   to fetch.  If you want to load *ALL* attributes for the named items,
-      #   then pass the symbol +:all+.
+      #   then pass the symbol `:all`.
       #
-      #     # get all attributes
-      #     batch_get.table('mytable', :all, items)
+      #       # get all attributes
+      #       batch_get.table('mytable', :all, items)
       #
-      #     # get one attribute for each item
-      #     batch_get.table('mytable', ['name'], items)
+      #       # get one attribute for each item
+      #       batch_get.table('mytable', ['name'], items)
       #
-      #     # get a list of attributes for each item
-      #     batch_get.table('mytable', ['name', 'size'], items)
+      #       # get a list of attributes for each item
+      #       batch_get.table('mytable', ['name', 'size'], items)
       #
       # @param [Array<Item,Array>] items One or more items to fetch attributes
       #   for.  Each attribute should be one of the following:
       #
-      #   * an {Item} object
-      #   * a hash key value
-      #   * a hash key value and a range key value
+      #     * an {Item} object
+      #     * a hash key value
+      #     * a hash key value and a range key value
       #
       #   You must provide both the hash key and range key values if the table
       #   schema has both.
       #
-      #     batch_get.table('mytable', :all, [%w(hk1 rk1), %w(hk1 rk2), ...])
+      #       batch_get.table('mytable', :all, [%w(hk1 rk1), %w(hk1 rk2), ...])
       #
       # @param [Hash] options
       #
-      # @option options [Boolean] :consistent_read (false) When +true+, items
-      #   are read from this table with consistent reads.  When +false+, reads
+      # @option options [Boolean] :consistent_read (false) When `true`, items
+      #   are read from this table with consistent reads.  When `false`, reads
       #   are eventually consistent.
       #
       # @return [nil]
@@ -88,8 +88,8 @@ module AWS
           end
         end
 
-        ## ensure we don't receive 2 different lists of attributes for
-        ## the same table
+        # ensure we don't receive 2 different lists of attributes for
+        # the same table
 
         if
           @request_items.has_key?(table) and
@@ -101,7 +101,7 @@ module AWS
           raise ArgumentError, msg
         end
 
-        ## merge attributes and items with the request items
+        # merge attributes and items with the request items
 
         @request_items[table] ||= { :keys => [] }
         @request_items[table][:attributes_to_get] = attributes if attributes
@@ -118,16 +118,16 @@ module AWS
       #
       # @param [Symbol, String, Array<String>] attributes The list of attributes
       #   to fetch.  If you want to load *ALL* attributes for the named items,
-      #   then pass the symbol +:all+.
+      #   then pass the symbol `:all`.
       #
-      #     # get all attributes
-      #     batch_get.table('mytable', :all, items)
+      #       # get all attributes
+      #       batch_get.table('mytable', :all, items)
       #
-      #     # get one attribute for each item
-      #     batch_get.table('mytable', ['name'], items)
+      #       # get one attribute for each item
+      #       batch_get.table('mytable', ['name'], items)
       #
-      #     # get a list of attributes for each item
-      #     batch_get.table('mytable', ['name', 'size'], items)
+      #       # get a list of attributes for each item
+      #       batch_get.table('mytable', ['name', 'size'], items)
       #
       # @param [Item] items One or more {Item} objects to fetch attributes
       #   for.  These items may come from any number of different tables.

data/lib/aws/dynamo_db/batch_write.rb

@@ -25,25 +25,25 @@ module AWS
 
       # Adds one or more items to the batch write operation.
       #
-      #   # adding one item at a time to the batch
-      #   batch = AWS::DynamoDB::BatchWrite.new
-      #   batch.put('table-name', :id => 'id1', :color => 'red')
-      #   batch.put('table-name', :id => 'id2', :color => 'blue')
-      #   batch.process!
-      #
-      #   # adding multiple items to a batch
-      #   batch = AWS::DynamoDB::BatchWrite.new
-      #   batch.put('table-name', [
-      #     { :id => 'id1', :color => 'red' },
-      #     { :id => 'id2', :color => 'blue' },
-      #     { :id => 'id3', :color => 'green' },
-      #   ])
-      #   batch.process!
+      #     # adding one item at a time to the batch
+      #     batch = AWS::DynamoDB::BatchWrite.new
+      #     batch.put('table-name', :id => 'id1', :color => 'red')
+      #     batch.put('table-name', :id => 'id2', :color => 'blue')
+      #     batch.process!
+      #
+      #     # adding multiple items to a batch
+      #     batch = AWS::DynamoDB::BatchWrite.new
+      #     batch.put('table-name', [
+      #       { :id => 'id1', :color => 'red' },
+      #       { :id => 'id2', :color => 'blue' },
+      #       { :id => 'id3', :color => 'green' },
+      #     ])
+      #     batch.process!
       #
       # @param [Table,String] table A {Table} object or table name string.
       #
       # @param [Array<Hash>] items A list of item attributes to put.
-      #   The hash must contain the table hash key element and range key 
+      #   The hash must contain the table hash key element and range key
       #   element (if one is defined).
       #
       # @return [nil]
@@ -55,28 +55,28 @@ module AWS
 
       # Adds one or more items to the batch to delete.
       #
-      #   # for a table w/out a range key
-      #   batch = AWS::DynamoDB::BatchWrite.new
-      #   batch.delete('table-name', %w(hk1 hk2))
-      #   batch.process!
+      #     # for a table w/out a range key
+      #     batch = AWS::DynamoDB::BatchWrite.new
+      #     batch.delete('table-name', %w(hk1 hk2))
+      #     batch.process!
       #
-      #   # for a table with a range key
-      #   batch = AWS::DynamoDB::BatchWrite.new
-      #   batch.delete('table-name', [['hk1', 'rk2'], ['hk1', 'rk2']]])
-      #   batch.process!
+      #     # for a table with a range key
+      #     batch = AWS::DynamoDB::BatchWrite.new
+      #     batch.delete('table-name', [['hk1', 'rk2'], ['hk1', 'rk2']]])
+      #     batch.process!
       #
       # @param [Table,String] table A {Table} object or table name string.
       #
-      # @param [Array<String>,Array<Array>] items A list of item keys to 
+      # @param [Array<String>,Array<Array>] items A list of item keys to
       #   delete.  For tables without a range key, items should be an array
       #   of hash key strings.
       #
-      #      batch.delete('table-name', ['hk1', 'hk2', 'hk3'])
+      #       batch.delete('table-name', ['hk1', 'hk2', 'hk3'])
       #
-      #   For tables with a range key, items should be an array of 
+      #   For tables with a range key, items should be an array of
       #   hash key and range key pairs.
       #
-      #      batch.delete('table-name', [['hk1', 'rk1'], ['hk1', 'rk2']])
+      #       batch.delete('table-name', [['hk1', 'rk1'], ['hk1', 'rk2']])
       #
       # @return [nil]
       #
@@ -95,27 +95,27 @@ module AWS
       # @option options [Array<Hash>] :put An array of items to put.  Each item
       #   should be an array of attribute hashes.
       #
-      #     # add 3 items to the batch
-      #     batch.write(table, :put => [
-      #       { :id => 'abc', :color => 'red', :count => 2 },
-      #       { :id => 'mno', :color => 'blue', :count => 3 },
-      #       { :id => 'xyz', :color => 'green', :count => 5 },
-      #     ])
+      #       # add 3 items to the batch
+      #       batch.write(table, :put => [
+      #         { :id => 'abc', :color => 'red', :count => 2 },
+      #         { :id => 'mno', :color => 'blue', :count => 3 },
+      #         { :id => 'xyz', :color => 'green', :count => 5 },
+      #       ])
       #
       # @option options [Array<String>,Array<Array>] :delete A list of item keys
       #   to delete.  For tables without a range key, items should be an array
       #   of hash key strings.
       #
-      #      batch.write('table-name', :delete => ['hk1', 'hk2', 'hk3'])
+      #       batch.write('table-name', :delete => ['hk1', 'hk2', 'hk3'])
       #
-      #   For tables with a range key, items should be an array of 
+      #   For tables with a range key, items should be an array of
       #   hash key and range key pairs.
       #
-      #      batch.write('table-name', :delete => [['hk1', 'rk1'], ['hk1', 'rk2']])
+      #       batch.write('table-name', :delete => [['hk1', 'rk1'], ['hk1', 'rk2']])
       #
       def write table, options = {}
 
-        items = table_items(table) 
+        items = table_items(table)
 
         if put = options[:put]
           put.each do |attributes|
@@ -198,7 +198,7 @@ module AWS
 
             item = request.values.first
 
-            request_items[table] << 
+            request_items[table] <<
               case request.keys.first
               when 'PutRequest'    then convert_put_item(item['Item'])
               when 'DeleteRequest' then convert_delete_item(item['Key'])
@@ -213,13 +213,13 @@ module AWS
       end
 
       def convert_put_item item
-        
+
         attributes = {}
         item.each_pair do |name,value|
           attributes[name] = str2sym(value)
         end
-        
-        { :put_request => { :item => attributes }} 
+
+        { :put_request => { :item => attributes }}
 
       end
 
@@ -227,7 +227,7 @@ module AWS
 
         key = {}
         key[:hash_key_element] = str2sym(item['HashKeyElement'])
-        key[:range_key_element] = str2sym(item['RangeKeyElement']) if 
+        key[:range_key_element] = str2sym(item['RangeKeyElement']) if
           item['RangeKeyElement']
 
         { :delete_request => { :key => key}}
@@ -242,7 +242,7 @@ module AWS
         when "N"  then { :n  => value }
         when "SS" then { :ss => value }
         when "NS" then { :ns => value }
-        else 
+        else
           raise "unhandled key type: #{type.inspect}"
         end
       end

data/lib/aws/dynamo_db/binary.rb

@@ -18,16 +18,16 @@ module AWS
     # to store as a binary attribute.  This can reduce the size
     # of larger attributes to save on storage costs.
     #
-    #   table = AWS::DynamoDB.new.tables['data-table']
-    #   table.hash_key = { 'id' => :string }
-    #   table.range_key = { 'position' => :number }
+    #     table = AWS::DynamoDB.new.tables['data-table']
+    #     table.hash_key = { 'id' => :string }
+    #     table.range_key = { 'position' => :number }
     #
-    #   # put an item with a binary data attribute
-    #   table.items.create(
-    #     'id' => 'abc',
-    #     'position' => 5,
-    #     'data' => AWS::DynamoDB::Binary.new('abc')
-    #   )
+    #     # put an item with a binary data attribute
+    #     table.items.create(
+    #       'id' => 'abc',
+    #       'position' => 5,
+    #       'data' => AWS::DynamoDB::Binary.new('abc')
+    #     )
     #
     class Binary < String; end
 

data/lib/aws/dynamo_db/client.rb

@@ -11,487 +11,497 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-require 'zlib'
-
 module AWS
   class DynamoDB
 
     # Client class for Amazon DynamoDB.
-    class Client < Core::JSONClient
-
-      # @private
-      REGION_US_E1 = 'dynamodb.us-east-1.amazonaws.com'
-
-      # @private
-      CACHEABLE_REQUESTS = Set[:list_tables, :describe_table]
+    class Client < ClientBase
 
       # client methods #
 
       # @!method batch_get_item(options = {})
       # Calls the BatchGetItem API operation.
       # @param [Hash] options
-      #   * +:request_items+ - *required* - (Hash<String,Hash>)
-      #     * +:keys+ - *required* - (Array<Hash>)
-      #       * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #   * `:request_items` - *required* - (Hash<String,Hash>)
+      #     * `:keys` - *required* - (Array<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
+      #         * `: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
+      #         * `: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
+      #         * `: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.
-      #       * +:range_key_element+ - (Hash) A range key element is treated as
+      #         * `:ss` - (Array<String>) A set of strings.
+      #         * `:ns` - (Array<String>) A set of numbers.
+      #         * `:bs` - (Array<String>) A set of binary attributes.
+      #       * `: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
+      #         * `: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
+      #         * `: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
+      #         * `: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)
+      #         * `: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)
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Responses+ - (Hash<String,Hash>)
-      #     * +member+ - (Hash<String,Hash>)
-      #       * +S+ - (String)
-      #       * +N+ - (String)
-      #       * +B+ - (String)
-      #       * +SS+ - (Array<String>)
-      #       * +NS+ - (Array<String>)
-      #       * +BS+ - (Array<Blob>)
-      #     * +ConsumedCapacityUnits+ - (Numeric)
-      #   * +UnprocessedKeys+ - (Hash<String,Hash>)
-      #     * +Keys+ - (Array<Hash>)
-      #       * +HashKeyElement+ - (Hash)
-      #         * +S+ - (String)
-      #         * +N+ - (String)
-      #         * +B+ - (String)
-      #         * +SS+ - (Array<String>)
-      #         * +NS+ - (Array<String>)
-      #         * +BS+ - (Array<Blob>)
-      #       * +RangeKeyElement+ - (Hash)
-      #         * +S+ - (String)
-      #         * +N+ - (String)
-      #         * +B+ - (String)
-      #         * +SS+ - (Array<String>)
-      #         * +NS+ - (Array<String>)
-      #         * +BS+ - (Array<Blob>)
-      #     * +AttributesToGet+ - (Array<String>)
-      #     * +ConsistentRead+ - (Boolean)
+      #   * `Responses` - (Hash<String,Hash>)
+      #     * `member` - (Hash<String,Hash>)
+      #       * `S` - (String)
+      #       * `N` - (String)
+      #       * `B` - (String)
+      #       * `SS` - (Array<String>)
+      #       * `NS` - (Array<String>)
+      #       * `BS` - (Array<Blob>)
+      #     * `ConsumedCapacityUnits` - (Numeric)
+      #   * `UnprocessedKeys` - (Hash<String,Hash>)
+      #     * `Keys` - (Array<Hash>)
+      #       * `HashKeyElement` - (Hash)
+      #         * `S` - (String)
+      #         * `N` - (String)
+      #         * `B` - (String)
+      #         * `SS` - (Array<String>)
+      #         * `NS` - (Array<String>)
+      #         * `BS` - (Array<Blob>)
+      #       * `RangeKeyElement` - (Hash)
+      #         * `S` - (String)
+      #         * `N` - (String)
+      #         * `B` - (String)
+      #         * `SS` - (Array<String>)
+      #         * `NS` - (Array<String>)
+      #         * `BS` - (Array<Blob>)
+      #     * `AttributesToGet` - (Array<String>)
+      #     * `ConsistentRead` - (Boolean)
 
       # @!method batch_write_item(options = {})
       # Calls the BatchWriteItem API operation.
       # @param [Hash] options
-      #   * +:request_items+ - *required* - (Hash<String,Array<Hash>>) A map of
+      #   * `: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
+      #     * `: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
+      #         * `: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
+      #         * `: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
-      #         * +:hash_key_element+ - *required* - (Hash) A hash key element
+      #         * `: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
+      #         * `: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
+      #           * `: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
+      #           * `: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
+      #           * `: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.
-      #         * +:range_key_element+ - (Hash) A range key element is treated
+      #           * `:ss` - (Array<String>) A set of strings.
+      #           * `:ns` - (Array<String>) A set of numbers.
+      #           * `:bs` - (Array<String>) A set of binary attributes.
+      #         * `: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
+      #           * `: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
+      #           * `: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
+      #           * `: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.
+      #           * `:ss` - (Array<String>) A set of strings.
+      #           * `:ns` - (Array<String>) A set of numbers.
+      #           * `:bs` - (Array<String>) A set of binary attributes.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Responses+ - (Hash<String,Hash>)
-      #     * +ConsumedCapacityUnits+ - (Numeric)
-      #   * +UnprocessedItems+ - (Hash<String,Hash>)
-      #     * +value+ - (Array<Hash>)
-      #       * +PutRequest+ - (Hash)
-      #         * +Item+ - (Hash<String,Hash>)
-      #           * +S+ - (String)
-      #           * +N+ - (String)
-      #           * +B+ - (String)
-      #           * +SS+ - (Array<String>)
-      #           * +NS+ - (Array<String>)
-      #           * +BS+ - (Array<Blob>)
-      #       * +DeleteRequest+ - (Hash)
-      #         * +Key+ - (Hash)
-      #           * +HashKeyElement+ - (Hash)
-      #             * +S+ - (String)
-      #             * +N+ - (String)
-      #             * +B+ - (String)
-      #             * +SS+ - (Array<String>)
-      #             * +NS+ - (Array<String>)
-      #             * +BS+ - (Array<Blob>)
-      #           * +RangeKeyElement+ - (Hash)
-      #             * +S+ - (String)
-      #             * +N+ - (String)
-      #             * +B+ - (String)
-      #             * +SS+ - (Array<String>)
-      #             * +NS+ - (Array<String>)
-      #             * +BS+ - (Array<Blob>)
+      #   * `Responses` - (Hash<String,Hash>)
+      #     * `ConsumedCapacityUnits` - (Numeric)
+      #   * `UnprocessedItems` - (Hash<String,Hash>)
+      #     * `value` - (Array<Hash>)
+      #       * `PutRequest` - (Hash)
+      #         * `Item` - (Hash<String,Hash>)
+      #           * `S` - (String)
+      #           * `N` - (String)
+      #           * `B` - (String)
+      #           * `SS` - (Array<String>)
+      #           * `NS` - (Array<String>)
+      #           * `BS` - (Array<Blob>)
+      #       * `DeleteRequest` - (Hash)
+      #         * `Key` - (Hash)
+      #           * `HashKeyElement` - (Hash)
+      #             * `S` - (String)
+      #             * `N` - (String)
+      #             * `B` - (String)
+      #             * `SS` - (Array<String>)
+      #             * `NS` - (Array<String>)
+      #             * `BS` - (Array<Blob>)
+      #           * `RangeKeyElement` - (Hash)
+      #             * `S` - (String)
+      #             * `N` - (String)
+      #             * `B` - (String)
+      #             * `SS` - (Array<String>)
+      #             * `NS` - (Array<String>)
+      #             * `BS` - (Array<Blob>)
 
       # @!method create_table(options = {})
       # Calls the CreateTable API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table you
+      #   * `: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)
-      #     * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #   * `:key_schema` - *required* - (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.
-      #       * +:attribute_name+ - *required* - (String) The AttributeName of
+      #       * `:attribute_name` - *required* - (String) The AttributeName of
       #         the KeySchemaElement.
-      #       * +:attribute_type+ - *required* - (String) The AttributeType of
-      #         the KeySchemaElement which can be a String or a Number.
-      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       * `:attribute_type` - *required* - (String) The AttributeType of
+      #         the KeySchemaElement which can be a String or a Number. Valid
+      #         values include:
+      #         * `S`
+      #         * `N`
+      #         * `B`
+      #     * `: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.
-      #       * +:attribute_name+ - *required* - (String) The AttributeName of
+      #       * `:attribute_name` - *required* - (String) The AttributeName of
       #         the KeySchemaElement.
-      #       * +:attribute_type+ - *required* - (String) The AttributeType of
-      #         the KeySchemaElement which can be a String or a Number.
-      #   * +:provisioned_throughput+ - *required* - (Hash)
-      #     * +:read_capacity_units+ - *required* - (Integer) ReadCapacityUnits
+      #       * `:attribute_type` - *required* - (String) The AttributeType of
+      #         the KeySchemaElement which can be a String or a Number. Valid
+      #         values include:
+      #         * `S`
+      #         * `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)
+      #     * `:write_capacity_units` - *required* - (Integer)
       #       WriteCapacityUnits are in terms of strictly consistent reads,
       #       assuming items of 1k. 2k items require twice the
       #       WriteCapacityUnits.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +TableDescription+ - (Hash)
-      #     * +TableName+ - (String)
-      #     * +KeySchema+ - (Hash)
-      #       * +HashKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #       * +RangeKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #     * +TableStatus+ - (String)
-      #     * +CreationDateTime+ - (Time)
-      #     * +ProvisionedThroughput+ - (Hash)
-      #       * +LastIncreaseDateTime+ - (Time)
-      #       * +LastDecreaseDateTime+ - (Time)
-      #       * +ReadCapacityUnits+ - (Integer)
-      #       * +WriteCapacityUnits+ - (Integer)
-      #     * +TableSizeBytes+ - (Integer)
-      #     * +ItemCount+ - (Integer)
+      #   * `TableDescription` - (Hash)
+      #     * `TableName` - (String)
+      #     * `KeySchema` - (Hash)
+      #       * `HashKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #       * `RangeKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #     * `TableStatus` - (String)
+      #     * `CreationDateTime` - (Time)
+      #     * `ProvisionedThroughput` - (Hash)
+      #       * `LastIncreaseDateTime` - (Time)
+      #       * `LastDecreaseDateTime` - (Time)
+      #       * `ReadCapacityUnits` - (Integer)
+      #       * `WriteCapacityUnits` - (Integer)
+      #     * `TableSizeBytes` - (Integer)
+      #     * `ItemCount` - (Integer)
 
       # @!method delete_item(options = {})
       # Calls the DeleteItem API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table in
+      #   * `: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)
-      #     * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #   * `:key` - *required* - (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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
-      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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>)
-      #     * +:value+ - (Hash) Specify whether or not a value already exists
+      #       * `: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>)
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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
+      #       * `: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)
+      #   * `:return_values` - (String) Valid values include:
+      #     * `NONE`
+      #     * `ALL_OLD`
+      #     * `UPDATED_OLD`
+      #     * `ALL_NEW`
+      #     * `UPDATED_NEW`
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Attributes+ - (Hash<String,Hash>)
-      #     * +S+ - (String)
-      #     * +N+ - (String)
-      #     * +B+ - (String)
-      #     * +SS+ - (Array<String>)
-      #     * +NS+ - (Array<String>)
-      #     * +BS+ - (Array<Blob>)
-      #   * +ConsumedCapacityUnits+ - (Numeric)
+      #   * `Attributes` - (Hash<String,Hash>)
+      #     * `S` - (String)
+      #     * `N` - (String)
+      #     * `B` - (String)
+      #     * `SS` - (Array<String>)
+      #     * `NS` - (Array<String>)
+      #     * `BS` - (Array<Blob>)
+      #   * `ConsumedCapacityUnits` - (Numeric)
 
       # @!method delete_table(options = {})
       # Calls the DeleteTable API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table you
+      #   * `: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).
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +TableDescription+ - (Hash)
-      #     * +TableName+ - (String)
-      #     * +KeySchema+ - (Hash)
-      #       * +HashKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #       * +RangeKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #     * +TableStatus+ - (String)
-      #     * +CreationDateTime+ - (Time)
-      #     * +ProvisionedThroughput+ - (Hash)
-      #       * +LastIncreaseDateTime+ - (Time)
-      #       * +LastDecreaseDateTime+ - (Time)
-      #       * +ReadCapacityUnits+ - (Integer)
-      #       * +WriteCapacityUnits+ - (Integer)
-      #     * +TableSizeBytes+ - (Integer)
-      #     * +ItemCount+ - (Integer)
+      #   * `TableDescription` - (Hash)
+      #     * `TableName` - (String)
+      #     * `KeySchema` - (Hash)
+      #       * `HashKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #       * `RangeKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #     * `TableStatus` - (String)
+      #     * `CreationDateTime` - (Time)
+      #     * `ProvisionedThroughput` - (Hash)
+      #       * `LastIncreaseDateTime` - (Time)
+      #       * `LastDecreaseDateTime` - (Time)
+      #       * `ReadCapacityUnits` - (Integer)
+      #       * `WriteCapacityUnits` - (Integer)
+      #     * `TableSizeBytes` - (Integer)
+      #     * `ItemCount` - (Integer)
 
       # @!method describe_table(options = {})
       # Calls the DescribeTable API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table you
+      #   * `: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).
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Table+ - (Hash)
-      #     * +TableName+ - (String)
-      #     * +KeySchema+ - (Hash)
-      #       * +HashKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #       * +RangeKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #     * +TableStatus+ - (String)
-      #     * +CreationDateTime+ - (Time)
-      #     * +ProvisionedThroughput+ - (Hash)
-      #       * +LastIncreaseDateTime+ - (Time)
-      #       * +LastDecreaseDateTime+ - (Time)
-      #       * +ReadCapacityUnits+ - (Integer)
-      #       * +WriteCapacityUnits+ - (Integer)
-      #     * +TableSizeBytes+ - (Integer)
-      #     * +ItemCount+ - (Integer)
+      #   * `Table` - (Hash)
+      #     * `TableName` - (String)
+      #     * `KeySchema` - (Hash)
+      #       * `HashKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #       * `RangeKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #     * `TableStatus` - (String)
+      #     * `CreationDateTime` - (Time)
+      #     * `ProvisionedThroughput` - (Hash)
+      #       * `LastIncreaseDateTime` - (Time)
+      #       * `LastDecreaseDateTime` - (Time)
+      #       * `ReadCapacityUnits` - (Integer)
+      #       * `WriteCapacityUnits` - (Integer)
+      #     * `TableSizeBytes` - (Integer)
+      #     * `ItemCount` - (Integer)
 
       # @!method get_item(options = {})
       # Calls the GetItem API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table in
+      #   * `: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)
-      #     * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #   * `:key` - *required* - (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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
-      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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)
+      #       * `: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)
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Item+ - (Hash<String,Hash>)
-      #     * +S+ - (String)
-      #     * +N+ - (String)
-      #     * +B+ - (String)
-      #     * +SS+ - (Array<String>)
-      #     * +NS+ - (Array<String>)
-      #     * +BS+ - (Array<Blob>)
-      #   * +ConsumedCapacityUnits+ - (Numeric)
+      #   * `Item` - (Hash<String,Hash>)
+      #     * `S` - (String)
+      #     * `N` - (String)
+      #     * `B` - (String)
+      #     * `SS` - (Array<String>)
+      #     * `NS` - (Array<String>)
+      #     * `BS` - (Array<Blob>)
+      #   * `ConsumedCapacityUnits` - (Numeric)
 
       # @!method list_tables(options = {})
       # Calls the ListTables API operation.
       # @param [Hash] options
-      #   * +:exclusive_start_table_name+ - (String) The name of the table that
+      #   * `: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
       #     value here to continue the list.
-      #   * +:limit+ - (Integer)
+      #   * `:limit` - (Integer)
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +TableNames+ - (Array<String>)
-      #   * +LastEvaluatedTableName+ - (String)
+      #   * `TableNames` - (Array<String>)
+      #   * `LastEvaluatedTableName` - (String)
 
       # @!method put_item(options = {})
       # Calls the PutItem API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table in
+      #   * `: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.
+      #   * `: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
+      #     * `: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
+      #     * `: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>)
-      #     * +:value+ - (Hash) Specify whether or not a value already exists
+      #     * `: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>)
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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
+      #       * `: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)
+      #   * `:return_values` - (String) Valid values include:
+      #     * `NONE`
+      #     * `ALL_OLD`
+      #     * `UPDATED_OLD`
+      #     * `ALL_NEW`
+      #     * `UPDATED_NEW`
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Attributes+ - (Hash<String,Hash>)
-      #     * +S+ - (String)
-      #     * +N+ - (String)
-      #     * +B+ - (String)
-      #     * +SS+ - (Array<String>)
-      #     * +NS+ - (Array<String>)
-      #     * +BS+ - (Array<Blob>)
-      #   * +ConsumedCapacityUnits+ - (Numeric)
+      #   * `Attributes` - (Hash<String,Hash>)
+      #     * `S` - (String)
+      #     * `N` - (String)
+      #     * `B` - (String)
+      #     * `SS` - (Array<String>)
+      #     * `NS` - (Array<String>)
+      #     * `BS` - (Array<Blob>)
+      #   * `ConsumedCapacityUnits` - (Numeric)
 
       # @!method query(options = {})
       # Calls the Query API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table in
+      #   * `: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
+      #   * `: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
@@ -499,122 +509,136 @@ module AWS
       #     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.
-      #   * +:consistent_read+ - (Boolean)
-      #   * +:count+ - (Boolean) If set to +true+ , Amazon DynamoDB returns a
+      #   * `: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
       #     list of the matching items and their attributes. Do not set Count
-      #     to +true+ while providing a list of AttributesToGet, otherwise
+      #     to `true` while providing a list of AttributesToGet, otherwise
       #     Amazon DynamoDB returns a validation error.
-      #   * +:hash_key_value+ - *required* - (Hash) Attribute value of the hash
+      #   * `: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.
+      #     * `: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
+      #     * `: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
+      #     * `: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.
-      #   * +:range_key_condition+ - (Hash) A container for the attribute
+      #     * `:ss` - (Array<String>) A set of strings.
+      #     * `:ns` - (Array<String>) A set of numbers.
+      #     * `:bs` - (Array<String>) A set of binary attributes.
+      #   * `: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.
+      #     * `: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
+      #       * `: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
+      #       * `: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)
-      #   * +:scan_index_forward+ - (Boolean) Specifies forward or backward
+      #       * `: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:
+      #       * `EQ`
+      #       * `NE`
+      #       * `IN`
+      #       * `LE`
+      #       * `LT`
+      #       * `GE`
+      #       * `GT`
+      #       * `BETWEEN`
+      #       * `NOT_NULL`
+      #       * `NULL`
+      #       * `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+
+      #     the requested order, determined by the range key. Default is `true`
       #     (forward).
-      #   * +:exclusive_start_key+ - (Hash) Primary key of the item from which
+      #   * `: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.
-      #     * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
-      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +member+ - (Hash<String,Hash>)
-      #     * +S+ - (String)
-      #     * +N+ - (String)
-      #     * +B+ - (String)
-      #     * +SS+ - (Array<String>)
-      #     * +NS+ - (Array<String>)
-      #     * +BS+ - (Array<Blob>)
-      #   * +Count+ - (Integer)
-      #   * +LastEvaluatedKey+ - (Hash)
-      #     * +HashKeyElement+ - (Hash)
-      #       * +S+ - (String)
-      #       * +N+ - (String)
-      #       * +B+ - (String)
-      #       * +SS+ - (Array<String>)
-      #       * +NS+ - (Array<String>)
-      #       * +BS+ - (Array<Blob>)
-      #     * +RangeKeyElement+ - (Hash)
-      #       * +S+ - (String)
-      #       * +N+ - (String)
-      #       * +B+ - (String)
-      #       * +SS+ - (Array<String>)
-      #       * +NS+ - (Array<String>)
-      #       * +BS+ - (Array<Blob>)
-      #   * +ConsumedCapacityUnits+ - (Numeric)
+      #   * `member` - (Hash<String,Hash>)
+      #     * `S` - (String)
+      #     * `N` - (String)
+      #     * `B` - (String)
+      #     * `SS` - (Array<String>)
+      #     * `NS` - (Array<String>)
+      #     * `BS` - (Array<Blob>)
+      #   * `Count` - (Integer)
+      #   * `LastEvaluatedKey` - (Hash)
+      #     * `HashKeyElement` - (Hash)
+      #       * `S` - (String)
+      #       * `N` - (String)
+      #       * `B` - (String)
+      #       * `SS` - (Array<String>)
+      #       * `NS` - (Array<String>)
+      #       * `BS` - (Array<Blob>)
+      #     * `RangeKeyElement` - (Hash)
+      #       * `S` - (String)
+      #       * `N` - (String)
+      #       * `B` - (String)
+      #       * `SS` - (Array<String>)
+      #       * `NS` - (Array<String>)
+      #       * `BS` - (Array<Blob>)
+      #   * `ConsumedCapacityUnits` - (Numeric)
 
       # @!method scan(options = {})
       # Calls the Scan API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table in
+      #   * `: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).
-      #   * +:attributes_to_get+ - (Array<String>)
-      #   * +:limit+ - (Integer) The maximum number of items to return. If
+      #   * `: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
@@ -622,283 +646,244 @@ module AWS
       #     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.
-      #   * +:count+ - (Boolean) If set to +true+ , Amazon DynamoDB returns a
+      #   * `: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
+      #     `true` while providing a list of AttributesToGet, otherwise Amazon
       #     DynamoDB returns a validation error.
-      #   * +:scan_filter+ - (Hash<String,Hash>) Evaluates the scan results and
+      #   * `: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.
+      #     * `: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
+      #       * `: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
+      #       * `: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)
-      #   * +:exclusive_start_key+ - (Hash) Primary key of the item from which
+      #       * `: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:
+      #       * `EQ`
+      #       * `NE`
+      #       * `IN`
+      #       * `LE`
+      #       * `LT`
+      #       * `GE`
+      #       * `GT`
+      #       * `BETWEEN`
+      #       * `NOT_NULL`
+      #       * `NULL`
+      #       * `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.
-      #     * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
-      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +member+ - (Hash<String,Hash>)
-      #     * +S+ - (String)
-      #     * +N+ - (String)
-      #     * +B+ - (String)
-      #     * +SS+ - (Array<String>)
-      #     * +NS+ - (Array<String>)
-      #     * +BS+ - (Array<Blob>)
-      #   * +Count+ - (Integer)
-      #   * +ScannedCount+ - (Integer)
-      #   * +LastEvaluatedKey+ - (Hash)
-      #     * +HashKeyElement+ - (Hash)
-      #       * +S+ - (String)
-      #       * +N+ - (String)
-      #       * +B+ - (String)
-      #       * +SS+ - (Array<String>)
-      #       * +NS+ - (Array<String>)
-      #       * +BS+ - (Array<Blob>)
-      #     * +RangeKeyElement+ - (Hash)
-      #       * +S+ - (String)
-      #       * +N+ - (String)
-      #       * +B+ - (String)
-      #       * +SS+ - (Array<String>)
-      #       * +NS+ - (Array<String>)
-      #       * +BS+ - (Array<Blob>)
-      #   * +ConsumedCapacityUnits+ - (Numeric)
+      #   * `member` - (Hash<String,Hash>)
+      #     * `S` - (String)
+      #     * `N` - (String)
+      #     * `B` - (String)
+      #     * `SS` - (Array<String>)
+      #     * `NS` - (Array<String>)
+      #     * `BS` - (Array<Blob>)
+      #   * `Count` - (Integer)
+      #   * `ScannedCount` - (Integer)
+      #   * `LastEvaluatedKey` - (Hash)
+      #     * `HashKeyElement` - (Hash)
+      #       * `S` - (String)
+      #       * `N` - (String)
+      #       * `B` - (String)
+      #       * `SS` - (Array<String>)
+      #       * `NS` - (Array<String>)
+      #       * `BS` - (Array<Blob>)
+      #     * `RangeKeyElement` - (Hash)
+      #       * `S` - (String)
+      #       * `N` - (String)
+      #       * `B` - (String)
+      #       * `SS` - (Array<String>)
+      #       * `NS` - (Array<String>)
+      #       * `BS` - (Array<Blob>)
+      #   * `ConsumedCapacityUnits` - (Numeric)
 
       # @!method update_item(options = {})
       # Calls the UpdateItem API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table in
+      #   * `: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)
-      #     * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #   * `:key` - *required* - (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.
+      #       * `: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
+      #       * `: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
+      #       * `: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.
-      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       * `:ss` - (Array<String>) A set of strings.
+      #       * `:ns` - (Array<String>) A set of numbers.
+      #       * `:bs` - (Array<String>) A set of binary attributes.
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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>)
-      #     * +:value+ - (Hash)
-      #       * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       * `: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>)
+      #     * `: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
+      #       * `: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
+      #       * `: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)
-      #   * +:expected+ - (Hash<String,Hash>)
-      #     * +:value+ - (Hash) Specify whether or not a value already exists
+      #       * `: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:
+      #       * `ADD`
+      #       * `PUT`
+      #       * `DELETE`
+      #   * `:expected` - (Hash<String,Hash>)
+      #     * `: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.
+      #       * `: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
+      #       * `: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
+      #       * `: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
+      #       * `: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)
+      #   * `:return_values` - (String) Valid values include:
+      #     * `NONE`
+      #     * `ALL_OLD`
+      #     * `UPDATED_OLD`
+      #     * `ALL_NEW`
+      #     * `UPDATED_NEW`
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +Attributes+ - (Hash<String,Hash>)
-      #     * +S+ - (String)
-      #     * +N+ - (String)
-      #     * +B+ - (String)
-      #     * +SS+ - (Array<String>)
-      #     * +NS+ - (Array<String>)
-      #     * +BS+ - (Array<Blob>)
-      #   * +ConsumedCapacityUnits+ - (Numeric)
+      #   * `Attributes` - (Hash<String,Hash>)
+      #     * `S` - (String)
+      #     * `N` - (String)
+      #     * `B` - (String)
+      #     * `SS` - (Array<String>)
+      #     * `NS` - (Array<String>)
+      #     * `BS` - (Array<Blob>)
+      #   * `ConsumedCapacityUnits` - (Numeric)
 
       # @!method update_table(options = {})
       # Calls the UpdateTable API operation.
       # @param [Hash] options
-      #   * +:table_name+ - *required* - (String) The name of the table you
+      #   * `: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).
-      #   * +:provisioned_throughput+ - *required* - (Hash)
-      #     * +:read_capacity_units+ - *required* - (Integer) ReadCapacityUnits
+      #   * `: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)
+      #     * `:write_capacity_units` - *required* - (Integer)
       #       WriteCapacityUnits are in terms of strictly consistent reads,
       #       assuming items of 1k. 2k items require twice the
       #       WriteCapacityUnits.
       # @return [Core::Response]
       #   The #data method of the response object returns
       #   a hash with the following structure:
-      #   * +TableDescription+ - (Hash)
-      #     * +TableName+ - (String)
-      #     * +KeySchema+ - (Hash)
-      #       * +HashKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #       * +RangeKeyElement+ - (Hash)
-      #         * +AttributeName+ - (String)
-      #         * +AttributeType+ - (String)
-      #     * +TableStatus+ - (String)
-      #     * +CreationDateTime+ - (Time)
-      #     * +ProvisionedThroughput+ - (Hash)
-      #       * +LastIncreaseDateTime+ - (Time)
-      #       * +LastDecreaseDateTime+ - (Time)
-      #       * +ReadCapacityUnits+ - (Integer)
-      #       * +WriteCapacityUnits+ - (Integer)
-      #     * +TableSizeBytes+ - (Integer)
-      #     * +ItemCount+ - (Integer)
+      #   * `TableDescription` - (Hash)
+      #     * `TableName` - (String)
+      #     * `KeySchema` - (Hash)
+      #       * `HashKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #       * `RangeKeyElement` - (Hash)
+      #         * `AttributeName` - (String)
+      #         * `AttributeType` - (String)
+      #     * `TableStatus` - (String)
+      #     * `CreationDateTime` - (Time)
+      #     * `ProvisionedThroughput` - (Hash)
+      #       * `LastIncreaseDateTime` - (Time)
+      #       * `LastDecreaseDateTime` - (Time)
+      #       * `ReadCapacityUnits` - (Integer)
+      #       * `WriteCapacityUnits` - (Integer)
+      #     * `TableSizeBytes` - (Integer)
+      #     * `ItemCount` - (Integer)
 
       # end client methods #
 
       define_client_methods('2011-12-05')
 
-      protected
-
-      def extract_error_details response
-        if response.http_response.status == 413
-          ['RequestEntityTooLarge', 'Request entity too large']
-        elsif crc32_is_valid?(response) == false
-          ['CRC32CheckFailed', 'CRC32 integrity check failed']
-        else
-          super
-        end
-      end
-
-      def retryable_error? response
-        case response.error
-        when Errors::ProvisionedThroughputExceededException
-          config.dynamo_db_retry_throughput_errors?
-        when Errors::CRC32CheckFailed
-          true
-        else
-          super
-        end
-      end
-
-      def sleep_durations response
-
-        retry_count =
-          if expired_credentials?(response)
-            config.max_retries == 0 ? 0 : 1
-          else
-            config.max_retries { 10 }
-          end
-
-        # given a retry_count of 10, the sleep durations will look like:
-        # 0, 50, 100, 200, 400, 800, 1600, 3200, 6400, 12800 (milliseconds)
-        (0...retry_count).map do |n|
-          if n == 0
-            0
-          else
-            50 * (2 ** (n - 1)) / 1000.0
-          end
-        end
-
-      end
-
-      private
-
-      # @return [Boolean] whether the CRC32 response header matches the body.
-      # @return [nil] if no CRC32 header is present or we are not verifying CRC32
-      def crc32_is_valid? response
-        return nil unless config.dynamo_db_crc32
-        if crcs = response.http_response.headers['x-amz-crc32']
-          crcs[0].to_i == calculate_crc32(response)
-        else
-          nil
-        end
-      end
-
-      def calculate_crc32 response
-        Zlib.crc32(response.http_response.body)
-      end
-
     end
   end
 end