class Aws::DynamoDB::Table

def attribute_definitions
  data[:attribute_definitions]
end

def billing_mode_summary
  data[:billing_mode_summary]
end

def client
  @client
end

def creation_date_time
  data[:creation_date_time]
end

def data
  load unless @data
  @data
end

def data_loaded?
  !!@data
end

def delete(options = {})
  options = options.merge(table_name: @name)
  resp = @client.delete_table(options)
  resp.data
end

def delete_item(options = {})
  options = options.merge(table_name: @name)
  resp = @client.delete_item(options)
  resp.data
end

def extract_name(args, options)
  value = args[0] || options.delete(:name)
  case value
  when String then value
  when nil then raise ArgumentError, "missing required option :name"
  else
    msg = "expected :name to be a String, got #{value.class}"
    raise ArgumentError, msg
  end
end

def get_item(options = {})
  options = options.merge(table_name: @name)
  resp = @client.get_item(options)
  resp.data
end

def global_secondary_indexes
  data[:global_secondary_indexes]
end

def identifiers
  { name: @name }
end

def initialize(*args)
  options = Hash === args.last ? args.pop.dup : {}
  @name = extract_name(args, options)
  @data = options.delete(:data)
  @client = options.delete(:client) || Client.new(options)
end

def item_count
  data[:item_count]
end

def key_schema
  data[:key_schema]
end

def latest_stream_arn
  data[:latest_stream_arn]
end

def latest_stream_label
  data[:latest_stream_label]
end

def load
  resp = @client.describe_table(table_name: @name)
  @data = resp.table
  self
end

def local_secondary_indexes
  data[:local_secondary_indexes]
end

def name
  @name
end

def provisioned_throughput
  data[:provisioned_throughput]
end

def put_item(options = {})
  options = options.merge(table_name: @name)
  resp = @client.put_item(options)
  resp.data
end

def query(options = {})
  options = options.merge(table_name: @name)
  resp = @client.query(options)
  resp.data
end

def restore_summary
  data[:restore_summary]
end

def scan(options = {})
  options = options.merge(table_name: @name)
  resp = @client.scan(options)
  resp.data
end

def sse_description
  data[:sse_description]
end

def stream_specification
  data[:stream_specification]
end

def table_arn
  data[:table_arn]
end

def table_id
  data[:table_id]
end

def table_size_bytes
  data[:table_size_bytes]
end

def table_status
  data[:table_status]
end

def update(options = {})
  options = options.merge(table_name: @name)
  resp = @client.update_table(options)
  Table.new(
    name: @name,
    data: resp.data.table_description,
    client: @client
  )
end

def update_item(options = {})
  options = options.merge(table_name: @name)
  resp = @client.update_item(options)
  resp.data
end

def wait_until(options = {}, &block)
  self_copy = self.dup
  attempts = 0
  options[:max_attempts] = 10 unless options.key?(:max_attempts)
  options[:delay] ||= 10
  options[:poller] = Proc.new do
    attempts += 1
    if block.call(self_copy)
      [:success, self_copy]
    else
      self_copy.reload unless attempts == options[:max_attempts]
      :retry
    end
  end
  Aws::Waiters::Waiter.new(options).wait({})
end