aws-sdk 1.4.1 → 1.5.0

data/lib/aws/core/xml/root_frame.rb

@@ -0,0 +1,65 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+    module XML
+
+      class RootFrame < Frame
+        
+        def initialize rules
+          @inflected = {}
+          @indexes = {}
+          setup_indexes(rules)
+          super(self, nil, 'XML', rules)
+        end
+
+        def build_child_frame element_name
+          Frame.new(self, self, element_name, rules)
+        end
+
+        def value
+          value = @data.values.find{|v| v.is_a?(Hash) }
+          value ||= {}
+          value.merge(@indexes)
+        end
+
+        def add_to_index index_name, key, value
+          @indexes[index_name] ||= {}
+          @indexes[index_name][key] = value
+        end
+
+        # The root frame maintains a cache of inflected element names.
+        def inflect element_name
+          @inflected[element_name] ||= Inflection.ruby_name(element_name).to_sym
+        end
+
+        protected
+
+        # recursively crawls the parser rules and looks for elements
+        # that index values.  Adds an empty index for each of these.
+        def setup_indexes rules
+          if rules[:children]
+            rules[:children].each_pair do |child_name,child_rules|
+              if index = child_rules[:index]
+                @indexes[index[:name]] = {}
+              end
+              setup_indexes(child_rules)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/core/{configured_xml_grammars.rb → xml/sax_handlers/libxml.rb}

@@ -11,35 +11,37 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
+require 'libxml'
+
 module AWS
   module Core
+    module XML
+      module SaxHandlers
+        class LibXML
+          
+          include FrameStack
+          include ::LibXML::XML::SaxParser::Callbacks
+
+          def sax_parse xml
+            sax_parser = ::LibXML::XML::SaxParser.string(xml)
+            sax_parser.callbacks = self
+            sax_parser.parse
+          end
 
-    # @private
-    module ConfiguredXmlGrammars
-
-      # @private
-      module ClassMethods
+          def on_start_element_ns element_name, attributes, *ignore
+            start_element(element_name, attributes) 
+          end
 
-        include ConfiguredGrammars::ClassMethods
+          def on_end_element_ns *ignore
+            end_element
+          end
 
-        def base_grammar
-          if const_defined?(:BaseResponse)
-            const_get(:BaseResponse)
-          else
-            XmlGrammar
+          def on_characters chars
+            text(chars)
           end
-        end
 
-        def input_or_output
-          :output
         end
-
       end
-
-      def self.included(mod)
-        mod.extend(ClassMethods)
-      end
-
     end
   end
 end

data/lib/aws/core/xml/sax_handlers/nokogiri.rb

@@ -0,0 +1,55 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'nokogiri'
+
+module AWS
+  module Core
+    module XML
+      module SaxHandlers
+        class Nokogiri
+          
+          include FrameStack
+
+          def sax_parse xml
+            ::Nokogiri::XML::SAX::Parser.new(self).parse(xml)
+          end
+
+          def xmldecl(*args); end
+          def start_document; end
+          def end_document; end
+          def error(*args); end
+
+          def start_element_namespace element_name, attributes = [], *ignore
+
+            attributes = attributes.map.inject({}) do |hash,attr| 
+              hash.merge(attr.localname => attr.value)
+            end
+
+            start_element(element_name, attributes) 
+
+          end
+
+          def end_element_namespace *ignore
+            end_element
+          end
+
+          def characters chars
+            text(chars)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/aws/core/{authorize_with_session_token.rb → xml/sax_handlers/ox.rb}

@@ -11,19 +11,31 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
+require 'stringio'
+require 'ox'
+
 module AWS
   module Core
+    module XML
+      module SaxHandlers
+        class Ox
+
+          include FrameStack
+
+          def sax_parse xml
+            ::Ox.sax_parse(self, StringIO.new(xml))
+          end
 
-    # @private
-    module AuthorizeWithSessionToken
+          def start_element name
+            super(name.to_s)
+          end
+
+          def attr name, value
+            attributes(name.to_s => value)
+          end
 
-      def add_authorization! signer
-        if signer.respond_to?(:session_token) and token = signer.session_token
-          add_param("SecurityToken", token)
         end
-        super
       end
-
     end
   end
 end

data/lib/aws/core/{configured_option_grammars.rb → xml/sax_handlers/rexml.rb}

@@ -11,34 +11,33 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
+require 'rexml/document'
+require 'rexml/streamlistener'
+
 module AWS
   module Core
-
-    # @private
-    module ConfiguredOptionGrammars
-
-      module ClassMethods
-
-        include ConfiguredGrammars::ClassMethods
-
-        def base_grammar
-          if const_defined?(:BaseOptions)
-            const_get(:BaseOptions)
-          else
-            OptionGrammar
+    module XML
+      module SaxHandlers
+        class REXML
+  
+          include FrameStack
+          include ::REXML::StreamListener
+  
+          def sax_parse xml
+            source = ::REXML::Source.new(xml)
+            ::REXML::Parsers::StreamParser.new(source, self).parse
           end
+  
+          def tag_start name, attrs
+            start_element(name, attrs)
+          end
+    
+          def tag_end name
+            end_element
+          end
+  
         end
-
-        def input_or_output
-          :input
-        end
-
       end
-
-      def self.included(mod)
-        mod.extend(ClassMethods)
-      end
-
     end
   end
 end

data/lib/aws/core/xml/stub.rb

@@ -0,0 +1,123 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Core
+    module XML
+
+      # This class takes the rules from an XML parser and then
+      # returns a stubbed reponse.  This response has placeholder
+      # values based on the grammar, e.g.
+      #
+      # * Lists are stubbed with empty arrays
+      # * Indexes become empty hashes
+      # * Numeric types are returned as 0
+      # * etc
+      #
+      # This is used primarily to help with the AWS.stub! utility.
+      #
+      class Stub
+
+        # @param [Hash] rules
+        def initialize rules
+          @rules = rules
+        end
+
+        # @return [Hash]
+        attr_reader :rules
+
+        # Returns a hash with stubbed values as if it had parsed
+        # an empty xml document.  
+        # @return [Hash] 
+        def simulate 
+          if rules[:children]
+            data = stub_data_for(rules)
+            apply_empty_indexes(rules, data)
+            data
+          else
+            {}
+          end
+        end
+
+        # Returns a hash with stubbed values as if it had parsed
+        # an empty xml document.  
+        # @param [Hash] rules An XML::Parser rule set.
+        # @return [Hash] 
+        def self.simulate rules
+          stub = Stub.new(rules)
+          stub.simulate
+        end
+
+        protected
+        def stub_data_for rules, data = {}
+          rules[:children].each_pair do |name,child_rules|
+
+            # skip ignored elements
+            if child_rules[:ignore]
+              stub_data_for(child_rules, data) if child_rules[:children]
+              next
+            end
+
+            orig_data = data
+            if wrapper = child_rules[:wrap]
+              data[wrapper] ||= {}
+              data = data[wrapper]
+            end
+
+            ruby_name = child_rules[:rename] || 
+              Inflection.ruby_name(name.to_s).to_sym
+
+            if child_rules[:list]
+              data[ruby_name] = []
+            elsif child_rules[:map]
+              data[ruby_name] = {}
+            elsif child_rules[:children] and !child_rules[:children].empty?
+              data[ruby_name] = stub_data_for(child_rules)
+            else
+              data[ruby_name] = case child_rules[:type]
+                when :integer  then 0 
+                when :float    then 0.0
+                when :time     then Time.now
+                when :datetime then Date.parse(Time.now.to_s)
+                when :boolean  then false
+                else nil
+              end
+            end
+
+            # restore data incase it was redirected for wrapping
+            data = orig_data
+
+          end
+
+          data
+
+        end
+
+        protected
+        def apply_empty_indexes rules, data
+          
+          return unless rules[:children]
+          
+          rules[:children].each_pair do |name,child_rules|
+            if index = child_rules[:index]
+              data[index[:name]] = {}
+            end
+            apply_empty_indexes(child_rules, data)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/dynamo_db/batch_get.rb

@@ -33,7 +33,7 @@ module AWS
 
       # Add a list of items to fetch in this batch.  
       #
-      # @param [String] table_name The name of the table to fetch attributes
+      # @param [Table,String] table The name of the table to fetch attributes
       #   from.
       #
       # @param [Symbol, String, Array<String>] attributes The list of attributes

data/lib/aws/dynamo_db/client.rb

@@ -14,21 +14,23 @@
 module AWS
   class DynamoDB
 
-    # @private
-    class Client < Core::JsonClient
+    # Client class for Amazon DynamoDB.
+    class Client < Core::Client
 
-      API_VERSION = '2011-06-01'
+      API_VERSION = '2011-12-05'
 
+      extend Core::Client::QueryJSON
+
+      # @private
       REGION_US_E1 = 'dynamodb.us-east-1.amazonaws.com'
 
+      # @private
       TARGET_PREFIX = "DynamoDB_20111205."
 
-      REQUEST_CLASS = DynamoDB::Request
-
+      # @private
       CACHEABLE_REQUESTS = Set[:list_tables, :describe_table]
 
-      configure_client
-
+      # @private
       def initialize *args
 
         super
@@ -43,16 +45,799 @@ module AWS
 
       end
 
+      ## client methods ##
+
+      # Calls the BatchGetItem API operation.
+      # @method batch_get_item(options = {})
+      #
+      # === Options:
+      #
+      # * +: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 encoding.
+      #         The maximum size is limited by the size of the primary key
+      #         (1024 bytes as a range part of a key or 2048 bytes as a single
+      #         part hash key) or the item size (64k).
+      #       * +:n+ - (String) Numbers are positive or negative exact-value
+      #         decimals and integers. A number can have up to 38 digits
+      #         precision and can be between 10^-128 to 10^+126.
+      #       * +:ss+ - (Array<String>) A set of strings.
+      #       * +:ns+ - (Array<String>) A set of numbers.
+      #     * +:range_key_element+ - (Hash) A range key element is treated as a
+      #       secondary key (used in conjunction with the primary key), and can
+      #       be a string or a number, and is only used for hash-and-range
+      #       primary keys. The value can be String, Number, StringSet,
+      #       NumberSet.
+      #       * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #         The maximum size is limited by the size of the primary key
+      #         (1024 bytes as a range part of a key or 2048 bytes as a single
+      #         part hash key) or the item size (64k).
+      #       * +:n+ - (String) Numbers are positive or negative exact-value
+      #         decimals and integers. A number can have up to 38 digits
+      #         precision and can be between 10^-128 to 10^+126.
+      #       * +:ss+ - (Array<String>) A set of strings.
+      #       * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:attributes_to_get+ - (Array<String>)
+      #
+      # === Response Structure:
+      #
+      # * +Responses+ - (Hash<String,Hash>)
+      #   * +member+ - (Hash<String,Hash>)
+      #     * +S+ - (String)
+      #     * +N+ - (String)
+      #     * +SS+ - (Array<String>)
+      #     * +NS+ - (Array<String>)
+      #   * +ConsumedCapacityUnits+ - (Numeric)
+      # * +UnprocessedKeys+ - (Hash<String,Hash>)
+      #   * +Keys+ - (Array<Hash>)
+      #     * +HashKeyElement+ - (Hash)
+      #       * +S+ - (String)
+      #       * +N+ - (String)
+      #       * +SS+ - (Array<String>)
+      #       * +NS+ - (Array<String>)
+      #     * +RangeKeyElement+ - (Hash)
+      #       * +S+ - (String)
+      #       * +N+ - (String)
+      #       * +SS+ - (Array<String>)
+      #       * +NS+ - (Array<String>)
+      #   * +AttributesToGet+ - (Array<String>)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :batch_get_item, 'BatchGetItem'
+
+      # Calls the BatchWriteItem API operation.
+      # @method batch_write_item(options = {})
+      #
+      # === Options:
+      #
+      # * +:request_items+ - *required* - (Hash<String,Array<Hash>>) A map of
+      #   table name to list-of-write-requests. Used as input to the
+      #   BatchWriteItem API call
+      #   * +:put_request+ - (Hash)
+      #     * +:item+ - *required* - (Hash<String,Hash>) The item to put
+      #       * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #         The maximum size is limited by the size of the primary key
+      #         (1024 bytes as a range part of a key or 2048 bytes as a single
+      #         part hash key) or the item size (64k).
+      #       * +:n+ - (String) Numbers are positive or negative exact-value
+      #         decimals and integers. A number can have up to 38 digits
+      #         precision and can be between 10^-128 to 10^+126.
+      #       * +:ss+ - (Array<String>) A set of strings.
+      #       * +:ns+ - (Array<String>) A set of numbers.
+      #   * +: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
+      #           encoding. The maximum size is limited by the size of the
+      #           primary key (1024 bytes as a range part of a key or 2048
+      #           bytes as a single part hash key) or the item size (64k).
+      #         * +:n+ - (String) Numbers are positive or negative exact-value
+      #           decimals and integers. A number can have up to 38 digits
+      #           precision and can be between 10^-128 to 10^+126.
+      #         * +:ss+ - (Array<String>) A set of strings.
+      #         * +:ns+ - (Array<String>) A set of numbers.
+      #       * +:range_key_element+ - (Hash) A range key element is treated as
+      #         a secondary key (used in conjunction with the primary key), and
+      #         can be a string or a number, and is only used for
+      #         hash-and-range primary keys. The value can be String, Number,
+      #         StringSet, NumberSet.
+      #         * +:s+ - (String) Strings are Unicode with UTF-8 binary
+      #           encoding. The maximum size is limited by the size of the
+      #           primary key (1024 bytes as a range part of a key or 2048
+      #           bytes as a single part hash key) or the item size (64k).
+      #         * +:n+ - (String) Numbers are positive or negative exact-value
+      #           decimals and integers. A number can have up to 38 digits
+      #           precision and can be between 10^-128 to 10^+126.
+      #         * +:ss+ - (Array<String>) A set of strings.
+      #         * +:ns+ - (Array<String>) A set of numbers.
+      #
+      # === Response Structure:
+      #
+      # * +Responses+ - (Hash<String,Hash>)
+      #   * +ConsumedCapacityUnits+ - (Numeric)
+      # * +UnprocessedItems+ - (Hash<String,Hash>)
+      #   * +value+ - (Array<Hash>)
+      #     * +PutRequest+ - (Hash)
+      #       * +Item+ - (Hash<String,Hash>)
+      #         * +S+ - (String)
+      #         * +N+ - (String)
+      #         * +SS+ - (Array<String>)
+      #         * +NS+ - (Array<String>)
+      #     * +DeleteRequest+ - (Hash)
+      #       * +Key+ - (Hash)
+      #         * +HashKeyElement+ - (Hash)
+      #           * +S+ - (String)
+      #           * +N+ - (String)
+      #           * +SS+ - (Array<String>)
+      #           * +NS+ - (Array<String>)
+      #         * +RangeKeyElement+ - (Hash)
+      #           * +S+ - (String)
+      #           * +N+ - (String)
+      #           * +SS+ - (Array<String>)
+      #           * +NS+ - (Array<String>)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :batch_write_item, 'BatchWriteItem'
+
+      # Calls the CreateTable API operation.
+      # @method create_table(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table you want
+      #   to create. Allowed characters are a-z, A-Z, 0-9, _ (underscore), -
+      #   (hyphen) and . (period).
+      # * +:key_schema+ - *required* - (Hash)
+      #   * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     treated as the primary key, and can be a string or a number. Single
+      #     attribute primary keys have one index value. The value can be
+      #     String, Number, StringSet, NumberSet.
+      #     * +:attribute_name+ - *required* - (String) The AttributeName of
+      #       the KeySchemaElement.
+      #     * +:attribute_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
+      #     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
+      #       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
+      #     are in terms of strictly consistent reads, assuming items of 1k. 2k
+      #     items require twice the ReadCapacityUnits. Eventually-consistent
+      #     reads only require half the ReadCapacityUnits of stirctly
+      #     consistent reads.
+      #   * +:write_capacity_units+ - *required* - (Integer) WriteCapacityUnits
+      #     are in terms of strictly consistent reads, assuming items of 1k. 2k
+      #     items require twice the WriteCapacityUnits.
+      #
+      # === Response 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)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :create_table, 'CreateTable'
+
+      # Calls the DeleteItem API operation.
+      # @method delete_item(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table in which
+      #   you want to delete an item. Allowed characters are a-z, A-Z, 0-9, _
+      #   (underscore), - (hyphen) and . (period).
+      # * +:key+ - *required* - (Hash)
+      #   * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     treated as the primary key, and can be a string or a number. Single
+      #     attribute primary keys have one index value. The value can be
+      #     String, Number, StringSet, NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:range_key_element+ - (Hash) A range key element is treated as a
+      #     secondary key (used in conjunction with the primary key), and can
+      #     be a string or a number, and is only used for hash-and-range
+      #     primary keys. The value can be String, Number, StringSet,
+      #     NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      # * +: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.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:exists+ - (Boolean) Specify whether or not a value already exists
+      #     for the attribute name-value pair.
+      # * +:return_values+ - (String)
+      #
+      # === Response Structure:
+      #
+      # * +Attributes+ - (Hash<String,Hash>)
+      #   * +S+ - (String)
+      #   * +N+ - (String)
+      #   * +SS+ - (Array<String>)
+      #   * +NS+ - (Array<String>)
+      # * +ConsumedCapacityUnits+ - (Numeric)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :delete_item, 'DeleteItem'
+
+      # Calls the DeleteTable API operation.
+      # @method delete_table(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table you want
+      #   to delete. Allowed characters are a-z, A-Z, 0-9, _ (underscore), -
+      #   (hyphen) and . (period).
+      #
+      # === Response 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)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :delete_table, 'DeleteTable'
+
+      # Calls the DescribeTable API operation.
+      # @method describe_table(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table you want
+      #   to describe. Allowed characters are a-z, A-Z, 0-9, _ (underscore), -
+      #   (hyphen) and . (period).
+      #
+      # === Response 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)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :describe_table, 'DescribeTable'
+
+      # Calls the GetItem API operation.
+      # @method get_item(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table in which
+      #   you want to get an item. Allowed characters are a-z, A-Z, 0-9, _
+      #   (underscore), - (hyphen) and . (period).
+      # * +:key+ - *required* - (Hash)
+      #   * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     treated as the primary key, and can be a string or a number. Single
+      #     attribute primary keys have one index value. The value can be
+      #     String, Number, StringSet, NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:range_key_element+ - (Hash) A range key element is treated as a
+      #     secondary key (used in conjunction with the primary key), and can
+      #     be a string or a number, and is only used for hash-and-range
+      #     primary keys. The value can be String, Number, StringSet,
+      #     NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      # * +:attributes_to_get+ - (Array<String>)
+      # * +:consistent_read+ - (Boolean)
+      #
+      # === Response Structure:
+      #
+      # * +Item+ - (Hash<String,Hash>)
+      #   * +S+ - (String)
+      #   * +N+ - (String)
+      #   * +SS+ - (Array<String>)
+      #   * +NS+ - (Array<String>)
+      # * +ConsumedCapacityUnits+ - (Numeric)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :get_item, 'GetItem'
+
+      # Calls the ListTables API operation.
+      # @method list_tables(options = {})
+      #
+      # === Options:
+      #
+      # * +:exclusive_start_table_name+ - (String) The name of the table that
+      #   starts the list. If you already ran a ListTables operation and
+      #   recieved a LastEvaluatedTableName value in the response, use that
+      #   value here to continue the list.
+      # * +:limit+ - (Integer)
+      #
+      # === Response Structure:
+      #
+      # * +TableNames+ - (Array<String>)
+      # * +LastEvaluatedTableName+ - (String)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :list_tables, 'ListTables'
+
+      # Calls the PutItem API operation.
+      # @method put_item(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table in which
+      #   you want to put an item. Allowed characters are a-z, A-Z, 0-9, _
+      #   (underscore), - (hyphen) and . (period).
+      # * +:item+ - *required* - (Hash<String,Hash>)
+      #   * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding. The
+      #     maximum size is limited by the size of the primary key (1024 bytes
+      #     as a range part of a key or 2048 bytes as a single part hash key)
+      #     or the item size (64k).
+      #   * +:n+ - (String) Numbers are positive or negative exact-value
+      #     decimals and integers. A number can have up to 38 digits precision
+      #     and can be between 10^-128 to 10^+126.
+      #   * +:ss+ - (Array<String>) A set of strings.
+      #   * +:ns+ - (Array<String>) A set of numbers.
+      # * +: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.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:exists+ - (Boolean) Specify whether or not a value already exists
+      #     for the attribute name-value pair.
+      # * +:return_values+ - (String)
+      #
+      # === Response Structure:
+      #
+      # * +Attributes+ - (Hash<String,Hash>)
+      #   * +S+ - (String)
+      #   * +N+ - (String)
+      #   * +SS+ - (Array<String>)
+      #   * +NS+ - (Array<String>)
+      # * +ConsumedCapacityUnits+ - (Numeric)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :put_item, 'PutItem'
+
+      # Calls the Query API operation.
+      # @method query(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table in which
+      #   you want to query. Allowed characters are a-z, A-Z, 0-9, _
+      #   (underscore), - (hyphen) and . (period).
+      # * +:attributes_to_get+ - (Array<String>)
+      # * +:limit+ - (Integer) The maximum number of items to return. If Amazon
+      #   DynamoDB hits this limit while querying the table, it stops the query
+      #   and returns the matching values up to the limit, and a
+      #   LastEvaluatedKey to apply in a subsequent operation to continue the
+      #   query. Also, if the result set size exceeds 1MB before Amazon
+      #   DynamoDB hits this limit, it stops the query and returns the matching
+      #   values, and a LastEvaluatedKey to apply in a subsequent operation to
+      #   continue the query.
+      # * +: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 Amazon
+      #   DynamoDB returns a validation error.
+      # * +:hash_key_value+ - *required* - (Hash) Attribute value of the hash
+      #   component of the composite primary key.
+      #   * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding. The
+      #     maximum size is limited by the size of the primary key (1024 bytes
+      #     as a range part of a key or 2048 bytes as a single part hash key)
+      #     or the item size (64k).
+      #   * +:n+ - (String) Numbers are positive or negative exact-value
+      #     decimals and integers. A number can have up to 38 digits precision
+      #     and can be between 10^-128 to 10^+126.
+      #   * +:ss+ - (Array<String>) A set of strings.
+      #   * +:ns+ - (Array<String>) A set of numbers.
+      # * +:range_key_condition+ - (Hash) A container for the attribute values
+      #   and comparison operators to use for the query.
+      #   * +:attribute_value_list+ - (Array<Hash>)
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:comparison_operator+ - *required* - (String)
+      # * +:scan_index_forward+ - (Boolean) Specifies forward or backward
+      #   traversal of the index. Amazon DynamoDB returns results reflecting
+      #   the requested order, determined by the range key. Default is +true+
+      #   (forward).
+      # * +:exclusive_start_key+ - (Hash) Primary key of the item from which to
+      #   continue an earlier query. An earlier query might provide this value
+      #   as the LastEvaluatedKey if that query operation was interrupted
+      #   before completing the query; either because of the result set size or
+      #   the Limit parameter. The LastEvaluatedKey can be passed back in a new
+      #   query request to continue the operation from that point.
+      #   * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     treated as the primary key, and can be a string or a number. Single
+      #     attribute primary keys have one index value. The value can be
+      #     String, Number, StringSet, NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:range_key_element+ - (Hash) A range key element is treated as a
+      #     secondary key (used in conjunction with the primary key), and can
+      #     be a string or a number, and is only used for hash-and-range
+      #     primary keys. The value can be String, Number, StringSet,
+      #     NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #
+      # === Response Structure:
+      #
+      # * +member+ - (Hash<String,Hash>)
+      #   * +S+ - (String)
+      #   * +N+ - (String)
+      #   * +SS+ - (Array<String>)
+      #   * +NS+ - (Array<String>)
+      # * +Count+ - (Integer)
+      # * +LastEvaluatedKey+ - (Hash)
+      #   * +HashKeyElement+ - (Hash)
+      #     * +S+ - (String)
+      #     * +N+ - (String)
+      #     * +SS+ - (Array<String>)
+      #     * +NS+ - (Array<String>)
+      #   * +RangeKeyElement+ - (Hash)
+      #     * +S+ - (String)
+      #     * +N+ - (String)
+      #     * +SS+ - (Array<String>)
+      #     * +NS+ - (Array<String>)
+      # * +ConsumedCapacityUnits+ - (Numeric)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :query, 'Query'
+
+      # Calls the Scan API operation.
+      # @method scan(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table in which
+      #   you want to scan. Allowed characters are a-z, A-Z, 0-9, _
+      #   (underscore), - (hyphen) and . (period).
+      # * +:attributes_to_get+ - (Array<String>)
+      # * +:limit+ - (Integer) The maximum number of items to return. If Amazon
+      #   DynamoDB hits this limit while scanning the table, it stops the scan
+      #   and returns the matching values up to the limit, and a
+      #   LastEvaluatedKey to apply in a subsequent operation to continue the
+      #   scan. Also, if the scanned data set size exceeds 1MB before Amazon
+      #   DynamoDB hits this limit, it stops the scan and returns the matching
+      #   values up to the limit, and a LastEvaluatedKey to apply in a
+      #   subsequent operation to continue the scan.
+      # * +:count+ - (Boolean) If set to +true+ , Amazon DynamoDB returns a
+      #   total number of items for the Scan operation, even if the operation
+      #   has no matching items for the assigned filter. Do not set Count to
+      #   +true+ while providing a list of AttributesToGet, otherwise Amazon
+      #   DynamoDB returns a validation error.
+      # * +:scan_filter+ - (Hash<String,Hash>) Evaluates the scan results and
+      #   returns only the desired values.
+      #   * +:attribute_value_list+ - (Array<Hash>)
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:comparison_operator+ - *required* - (String)
+      # * +: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
+      #     treated as the primary key, and can be a string or a number. Single
+      #     attribute primary keys have one index value. The value can be
+      #     String, Number, StringSet, NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:range_key_element+ - (Hash) A range key element is treated as a
+      #     secondary key (used in conjunction with the primary key), and can
+      #     be a string or a number, and is only used for hash-and-range
+      #     primary keys. The value can be String, Number, StringSet,
+      #     NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #
+      # === Response Structure:
+      #
+      # * +member+ - (Hash<String,Hash>)
+      #   * +S+ - (String)
+      #   * +N+ - (String)
+      #   * +SS+ - (Array<String>)
+      #   * +NS+ - (Array<String>)
+      # * +Count+ - (Integer)
+      # * +ScannedCount+ - (Integer)
+      # * +LastEvaluatedKey+ - (Hash)
+      #   * +HashKeyElement+ - (Hash)
+      #     * +S+ - (String)
+      #     * +N+ - (String)
+      #     * +SS+ - (Array<String>)
+      #     * +NS+ - (Array<String>)
+      #   * +RangeKeyElement+ - (Hash)
+      #     * +S+ - (String)
+      #     * +N+ - (String)
+      #     * +SS+ - (Array<String>)
+      #     * +NS+ - (Array<String>)
+      # * +ConsumedCapacityUnits+ - (Numeric)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :scan, 'Scan'
+
+      # Calls the UpdateItem API operation.
+      # @method update_item(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table in which
+      #   you want to update an item. Allowed characters are a-z, A-Z, 0-9, _
+      #   (underscore), - (hyphen) and . (period).
+      # * +:key+ - *required* - (Hash)
+      #   * +:hash_key_element+ - *required* - (Hash) A hash key element is
+      #     treated as the primary key, and can be a string or a number. Single
+      #     attribute primary keys have one index value. The value can be
+      #     String, Number, StringSet, NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:range_key_element+ - (Hash) A range key element is treated as a
+      #     secondary key (used in conjunction with the primary key), and can
+      #     be a string or a number, and is only used for hash-and-range
+      #     primary keys. The value can be String, Number, StringSet,
+      #     NumberSet.
+      #     * +:s+ - (String) Strings are Unicode with UTF-8 binary encoding.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      # * +: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
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:action+ - (String)
+      # * +: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.
+      #       The maximum size is limited by the size of the primary key (1024
+      #       bytes as a range part of a key or 2048 bytes as a single part
+      #       hash key) or the item size (64k).
+      #     * +:n+ - (String) Numbers are positive or negative exact-value
+      #       decimals and integers. A number can have up to 38 digits
+      #       precision and can be between 10^-128 to 10^+126.
+      #     * +:ss+ - (Array<String>) A set of strings.
+      #     * +:ns+ - (Array<String>) A set of numbers.
+      #   * +:exists+ - (Boolean) Specify whether or not a value already exists
+      #     for the attribute name-value pair.
+      # * +:return_values+ - (String)
+      #
+      # === Response Structure:
+      #
+      # * +Attributes+ - (Hash<String,Hash>)
+      #   * +S+ - (String)
+      #   * +N+ - (String)
+      #   * +SS+ - (Array<String>)
+      #   * +NS+ - (Array<String>)
+      # * +ConsumedCapacityUnits+ - (Numeric)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :update_item, 'UpdateItem'
+
+      # Calls the UpdateTable API operation.
+      # @method update_table(options = {})
+      #
+      # === Options:
+      #
+      # * +:table_name+ - *required* - (String) The name of the table you want
+      #   to update. Allowed characters are a-z, A-Z, 0-9, _ (underscore), -
+      #   (hyphen) and . (period).
+      # * +:provisioned_throughput+ - *required* - (Hash)
+      #   * +:read_capacity_units+ - *required* - (Integer) ReadCapacityUnits
+      #     are in terms of strictly consistent reads, assuming items of 1k. 2k
+      #     items require twice the ReadCapacityUnits. Eventually-consistent
+      #     reads only require half the ReadCapacityUnits of stirctly
+      #     consistent reads.
+      #   * +:write_capacity_units+ - *required* - (Integer) WriteCapacityUnits
+      #     are in terms of strictly consistent reads, assuming items of 1k. 2k
+      #     items require twice the WriteCapacityUnits.
+      #
+      # === Response 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)
+      #
+      # @return [Core::Response]
+      #
+      define_client_method :update_table, 'UpdateTable'
+
+      ## end client methods ##
+
       protected
-      def extract_error_code response
+
+      def extract_error_details response
         if response.http_response.status == 413
-          'RequestEntityTooLarge'
+          ['RequestEntityTooLarge', 'Request entity too large']
         else
-          super(response)
+          super
         end
       end
 
-      private
       def should_retry? response 
         if possible_expired_credentials?(response)
           true
@@ -63,7 +848,6 @@ module AWS
         end
       end
 
-      private
       def rebuild_http_request response
         # called when a request is going to be retried, in case of 
         # expired credentials we should refresh the session
@@ -71,7 +855,6 @@ module AWS
         super
       end
 
-      private
       def sleep_durations response
 
         retry_count = 
@@ -93,7 +876,6 @@ module AWS
 
       end
 
-      private
       # Returns true if we get an access denied error from the service AND
       # our signer is capible of getting new short-term credentials
       def possible_expired_credentials? response