-- AUTOGENERATED FILE - DO NOT EDIT
-- AWS Service: dynamodb

local common = require("nvim-aws.common")

--- AWS dynamodb service functions
local M = {}

--- AWS dynamodb batch-execute-statement operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.batch_execute_statement(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "batch-execute-statement" }, input, callbacks)
end

--- AWS dynamodb batch-get-item operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.batch_get_item(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "batch-get-item" }, input, callbacks)
end

--- AWS dynamodb batch-write-item operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.batch_write_item(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "batch-write-item" }, input, callbacks)
end

--- AWS dynamodb create-backup operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.create_backup(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "create-backup" }, input, callbacks)
end

--- AWS dynamodb create-global-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.create_global_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "create-global-table" }, input, callbacks)
end

--- AWS dynamodb create-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.create_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "create-table" }, input, callbacks)
end

--- AWS dynamodb delete-backup operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.delete_backup(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "delete-backup" }, input, callbacks)
end

--- AWS dynamodb delete-item operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.delete_item(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "delete-item" }, input, callbacks)
end

--- AWS dynamodb delete-resource-policy operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.delete_resource_policy(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "delete-resource-policy" }, input, callbacks)
end

--- AWS dynamodb delete-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.delete_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "delete-table" }, input, callbacks)
end

--- AWS dynamodb describe-backup operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_backup(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-backup" }, input, callbacks)
end

--- AWS dynamodb describe-continuous-backups operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_continuous_backups(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-continuous-backups" }, input, callbacks)
end

--- AWS dynamodb describe-contributor-insights operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_contributor_insights(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-contributor-insights" }, input, callbacks)
end

--- AWS dynamodb describe-endpoints operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_endpoints(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-endpoints" }, input, callbacks)
end

--- AWS dynamodb describe-export operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_export(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-export" }, input, callbacks)
end

--- AWS dynamodb describe-global-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_global_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-global-table" }, input, callbacks)
end

--- AWS dynamodb describe-global-table-settings operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_global_table_settings(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-global-table-settings" }, input, callbacks)
end

--- AWS dynamodb describe-import operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_import(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-import" }, input, callbacks)
end

--- AWS dynamodb describe-kinesis-streaming-destination operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_kinesis_streaming_destination(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-kinesis-streaming-destination" }, input, callbacks)
end

--- AWS dynamodb describe-limits operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_limits(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-limits" }, input, callbacks)
end

--- AWS dynamodb describe-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-table" }, input, callbacks)
end

--- AWS dynamodb describe-table-replica-auto-scaling operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_table_replica_auto_scaling(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-table-replica-auto-scaling" }, input, callbacks)
end

--- AWS dynamodb describe-time-to-live operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.describe_time_to_live(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "describe-time-to-live" }, input, callbacks)
end

--- AWS dynamodb disable-kinesis-streaming-destination operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.disable_kinesis_streaming_destination(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "disable-kinesis-streaming-destination" }, input, callbacks)
end

--- AWS dynamodb enable-kinesis-streaming-destination operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.enable_kinesis_streaming_destination(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "enable-kinesis-streaming-destination" }, input, callbacks)
end

--- AWS dynamodb execute-statement operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.execute_statement(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "execute-statement" }, input, callbacks)
end

--- AWS dynamodb execute-transaction operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.execute_transaction(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "execute-transaction" }, input, callbacks)
end

--- AWS dynamodb export-table-to-point-in-time operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.export_table_to_point_in_time(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "export-table-to-point-in-time" }, input, callbacks)
end

--- AWS dynamodb get-item operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.get_item(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "get-item" }, input, callbacks)
end

--- AWS dynamodb get-resource-policy operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.get_resource_policy(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "get-resource-policy" }, input, callbacks)
end

--- AWS dynamodb import-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.import_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "import-table" }, input, callbacks)
end

--- AWS dynamodb list-backups operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_backups(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-backups" }, input, callbacks)
end

--- AWS dynamodb list-contributor-insights operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_contributor_insights(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-contributor-insights" }, input, callbacks)
end

--- AWS dynamodb list-exports operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_exports(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-exports" }, input, callbacks)
end

--- AWS dynamodb list-global-tables operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_global_tables(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-global-tables" }, input, callbacks)
end

--- AWS dynamodb list-imports operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_imports(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-imports" }, input, callbacks)
end

--- AWS dynamodb list-tables operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_tables(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-tables" }, input, callbacks)
end

--- AWS dynamodb list-tags-of-resource operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.list_tags_of_resource(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "list-tags-of-resource" }, input, callbacks)
end

--- AWS dynamodb put-item operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.put_item(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "put-item" }, input, callbacks)
end

--- AWS dynamodb put-resource-policy operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.put_resource_policy(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "put-resource-policy" }, input, callbacks)
end

--- AWS dynamodb query operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.query(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "query" }, input, callbacks)
end

--- AWS dynamodb restore-table-from-backup operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.restore_table_from_backup(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "restore-table-from-backup" }, input, callbacks)
end

--- AWS dynamodb restore-table-to-point-in-time operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.restore_table_to_point_in_time(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "restore-table-to-point-in-time" }, input, callbacks)
end

--- AWS dynamodb scan operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.scan(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "scan" }, input, callbacks)
end

--- AWS dynamodb tag-resource operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.tag_resource(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "tag-resource" }, input, callbacks)
end

--- AWS dynamodb transact-get-items operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.transact_get_items(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "transact-get-items" }, input, callbacks)
end

--- AWS dynamodb transact-write-items operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.transact_write_items(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "transact-write-items" }, input, callbacks)
end

--- AWS dynamodb untag-resource operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.untag_resource(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "untag-resource" }, input, callbacks)
end

--- AWS dynamodb update-continuous-backups operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_continuous_backups(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-continuous-backups" }, input, callbacks)
end

--- AWS dynamodb update-contributor-insights operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_contributor_insights(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-contributor-insights" }, input, callbacks)
end

--- AWS dynamodb update-global-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_global_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-global-table" }, input, callbacks)
end

--- AWS dynamodb update-global-table-settings operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_global_table_settings(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-global-table-settings" }, input, callbacks)
end

--- AWS dynamodb update-item operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_item(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-item" }, input, callbacks)
end

--- AWS dynamodb update-kinesis-streaming-destination operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_kinesis_streaming_destination(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-kinesis-streaming-destination" }, input, callbacks)
end

--- AWS dynamodb update-table operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_table(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-table" }, input, callbacks)
end

--- AWS dynamodb update-table-replica-auto-scaling operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_table_replica_auto_scaling(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-table-replica-auto-scaling" }, input, callbacks)
end

--- AWS dynamodb update-time-to-live operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.update_time_to_live(input, callbacks)
	return common.execute_aws_command_skeleton({ "dynamodb", "update-time-to-live" }, input, callbacks)
end

--- AWS dynamodb wait operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.wait(input, callbacks)
	return common.execute_aws_command({ "dynamodb", "wait" }, input, callbacks)
end

--- AWS dynamodb wizard operation
--- @param input nil|table the input table
--- @param callbacks nil|{stdout?: fun(err: string, data: string), stderr?: fun(err: string, data: string), on_exit?: fun(out: vim.SystemCompleted)}
--- @return {success: boolean, data?: table, error?: string }|{success: boolean, job: vim.SystemObj}
function M.wizard(input, callbacks)
	return common.execute_aws_command({ "dynamodb", "wizard" }, input, callbacks)
end

return M
