class Aws::DynamoDB::Client

def batch_get_item(params = {}, options = {})
  req = build_request(:batch_get_item, params)
  req.send_request(options)
end

def batch_write_item(params = {}, options = {})
  req = build_request(:batch_write_item, params)
  req.send_request(options)
end

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config)
  context[:gem_name] = 'aws-sdk-dynamodb'
  context[:gem_version] = '1.40.0'
  Seahorse::Client::Request.new(handlers, context)
end

def create_backup(params = {}, options = {})
  req = build_request(:create_backup, params)
  req.send_request(options)
end

def create_global_table(params = {}, options = {})
  req = build_request(:create_global_table, params)
  req.send_request(options)
end

def create_table(params = {}, options = {})
  req = build_request(:create_table, params)
  req.send_request(options)
end

def data_to_http_resp(operation_name, data)
  api = config.api
  operation = api.operation(operation_name)
  translator = Plugins::SimpleAttributes::ValueTranslator
  translator = translator.new(operation.output, :marshal)
  data = translator.apply(data)
  ParamValidator.validate!(operation.output, data)
  protocol_helper.stub_data(api, operation, data)
end

def delete_backup(params = {}, options = {})
  req = build_request(:delete_backup, params)
  req.send_request(options)
end

def delete_item(params = {}, options = {})
  req = build_request(:delete_item, params)
  req.send_request(options)
end

def delete_table(params = {}, options = {})
  req = build_request(:delete_table, params)
  req.send_request(options)
end

def describe_backup(params = {}, options = {})
  req = build_request(:describe_backup, params)
  req.send_request(options)
end

def describe_continuous_backups(params = {}, options = {})
  req = build_request(:describe_continuous_backups, params)
  req.send_request(options)
end

def describe_contributor_insights(params = {}, options = {})
  req = build_request(:describe_contributor_insights, params)
  req.send_request(options)
end

def describe_endpoints(params = {}, options = {})
  req = build_request(:describe_endpoints, params)
  req.send_request(options)
end

def describe_global_table(params = {}, options = {})
  req = build_request(:describe_global_table, params)
  req.send_request(options)
end

def describe_global_table_settings(params = {}, options = {})
  req = build_request(:describe_global_table_settings, params)
  req.send_request(options)
end

def describe_limits(params = {}, options = {})
  req = build_request(:describe_limits, params)
  req.send_request(options)
end

def describe_table(params = {}, options = {})
  req = build_request(:describe_table, params)
  req.send_request(options)
end

def describe_table_replica_auto_scaling(params = {}, options = {})
  req = build_request(:describe_table_replica_auto_scaling, params)
  req.send_request(options)
end

def describe_time_to_live(params = {}, options = {})
  req = build_request(:describe_time_to_live, params)
  req.send_request(options)
end

def errors_module
  Errors
end

def get_item(params = {}, options = {})
  req = build_request(:get_item, params)
  req.send_request(options)
end

def initialize(*args)
  super
end

def list_backups(params = {}, options = {})
  req = build_request(:list_backups, params)
  req.send_request(options)
end

def list_contributor_insights(params = {}, options = {})
  req = build_request(:list_contributor_insights, params)
  req.send_request(options)
end

def list_global_tables(params = {}, options = {})
  req = build_request(:list_global_tables, params)
  req.send_request(options)
end

def list_tables(params = {}, options = {})
  req = build_request(:list_tables, params)
  req.send_request(options)
end

def list_tags_of_resource(params = {}, options = {})
  req = build_request(:list_tags_of_resource, params)
  req.send_request(options)
end

def put_item(params = {}, options = {})
  req = build_request(:put_item, params)
  req.send_request(options)
end

def query(params = {}, options = {})
  req = build_request(:query, params)
  req.send_request(options)
end

def restore_table_from_backup(params = {}, options = {})
  req = build_request(:restore_table_from_backup, params)
  req.send_request(options)
end

def restore_table_to_point_in_time(params = {}, options = {})
  req = build_request(:restore_table_to_point_in_time, params)
  req.send_request(options)
end

def scan(params = {}, options = {})
  req = build_request(:scan, params)
  req.send_request(options)
end

def stub_data(operation_name, data = {})
  if config.simple_attributes
    rules = config.api.operation(operation_name).output
    translator = Plugins::SimpleAttributes::ValueTranslator
    data = translator.apply(rules, :marshal, data)
    data = super(operation_name, data)
    translator.apply(rules, :unmarshal, data)
  else
    super
  end
end

def tag_resource(params = {}, options = {})
  req = build_request(:tag_resource, params)
  req.send_request(options)
end

def transact_get_items(params = {}, options = {})
  req = build_request(:transact_get_items, params)
  req.send_request(options)
end

def transact_write_items(params = {}, options = {})
  req = build_request(:transact_write_items, params)
  req.send_request(options)
end

def untag_resource(params = {}, options = {})
  req = build_request(:untag_resource, params)
  req.send_request(options)
end

def update_continuous_backups(params = {}, options = {})
  req = build_request(:update_continuous_backups, params)
  req.send_request(options)
end

def update_contributor_insights(params = {}, options = {})
  req = build_request(:update_contributor_insights, params)
  req.send_request(options)
end

def update_global_table(params = {}, options = {})
  req = build_request(:update_global_table, params)
  req.send_request(options)
end

def update_global_table_settings(params = {}, options = {})
  req = build_request(:update_global_table_settings, params)
  req.send_request(options)
end

def update_item(params = {}, options = {})
  req = build_request(:update_item, params)
  req.send_request(options)
end

def update_table(params = {}, options = {})
  req = build_request(:update_table, params)
  req.send_request(options)
end

def update_table_replica_auto_scaling(params = {}, options = {})
  req = build_request(:update_table_replica_auto_scaling, params)
  req.send_request(options)
end

def update_time_to_live(params = {}, options = {})
  req = build_request(:update_time_to_live, params)
  req.send_request(options)
end

def wait_until(waiter_name, params = {}, options = {})
  w = waiter(waiter_name, options)
  yield(w.waiter) if block_given? # deprecated
  w.wait(params)
end

def waiter(waiter_name, options = {})
  waiter_class = waiters[waiter_name]
  if waiter_class
    waiter_class.new(options.merge(client: self))
  else
    raise Aws::Waiters::Errors::NoSuchWaiterError.new(waiter_name, waiters.keys)
  end
end

def waiter_names
  waiters.keys
end

def waiters
  {
    table_exists: Waiters::TableExists,
    table_not_exists: Waiters::TableNotExists
  }
end