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

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

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

--- AWS s3api abort-multipart-upload 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.abort_multipart_upload(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "abort-multipart-upload" }, input, callbacks)
end

--- AWS s3api complete-multipart-upload 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.complete_multipart_upload(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "complete-multipart-upload" }, input, callbacks)
end

--- AWS s3api copy-object 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.copy_object(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "copy-object" }, input, callbacks)
end

--- AWS s3api create-bucket 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_bucket(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "create-bucket" }, input, callbacks)
end

--- AWS s3api create-bucket-metadata-table-configuration 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_bucket_metadata_table_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "create-bucket-metadata-table-configuration" }, input, callbacks)
end

--- AWS s3api create-multipart-upload 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_multipart_upload(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "create-multipart-upload" }, input, callbacks)
end

--- AWS s3api create-session 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_session(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "create-session" }, input, callbacks)
end

--- AWS s3api delete-bucket 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_bucket(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket" }, input, callbacks)
end

--- AWS s3api delete-bucket-analytics-configuration 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_bucket_analytics_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-analytics-configuration" }, input, callbacks)
end

--- AWS s3api delete-bucket-cors 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_bucket_cors(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-cors" }, input, callbacks)
end

--- AWS s3api delete-bucket-encryption 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_bucket_encryption(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-encryption" }, input, callbacks)
end

--- AWS s3api delete-bucket-intelligent-tiering-configuration 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_bucket_intelligent_tiering_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-intelligent-tiering-configuration" }, input, callbacks)
end

--- AWS s3api delete-bucket-inventory-configuration 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_bucket_inventory_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-inventory-configuration" }, input, callbacks)
end

--- AWS s3api delete-bucket-lifecycle 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_bucket_lifecycle(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-lifecycle" }, input, callbacks)
end

--- AWS s3api delete-bucket-metadata-table-configuration 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_bucket_metadata_table_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-metadata-table-configuration" }, input, callbacks)
end

--- AWS s3api delete-bucket-metrics-configuration 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_bucket_metrics_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-metrics-configuration" }, input, callbacks)
end

--- AWS s3api delete-bucket-ownership-controls 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_bucket_ownership_controls(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-ownership-controls" }, input, callbacks)
end

--- AWS s3api delete-bucket-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_bucket_policy(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-policy" }, input, callbacks)
end

--- AWS s3api delete-bucket-replication 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_bucket_replication(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-replication" }, input, callbacks)
end

--- AWS s3api delete-bucket-tagging 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_bucket_tagging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-tagging" }, input, callbacks)
end

--- AWS s3api delete-bucket-website 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_bucket_website(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-bucket-website" }, input, callbacks)
end

--- AWS s3api delete-object 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_object(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-object" }, input, callbacks)
end

--- AWS s3api delete-object-tagging 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_object_tagging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-object-tagging" }, input, callbacks)
end

--- AWS s3api delete-objects 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_objects(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-objects" }, input, callbacks)
end

--- AWS s3api delete-public-access-block 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_public_access_block(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "delete-public-access-block" }, input, callbacks)
end

--- AWS s3api get-bucket-accelerate-configuration 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_bucket_accelerate_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-accelerate-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-acl 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_bucket_acl(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-acl" }, input, callbacks)
end

--- AWS s3api get-bucket-analytics-configuration 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_bucket_analytics_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-analytics-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-cors 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_bucket_cors(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-cors" }, input, callbacks)
end

--- AWS s3api get-bucket-encryption 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_bucket_encryption(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-encryption" }, input, callbacks)
end

--- AWS s3api get-bucket-intelligent-tiering-configuration 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_bucket_intelligent_tiering_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-intelligent-tiering-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-inventory-configuration 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_bucket_inventory_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-inventory-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-lifecycle-configuration 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_bucket_lifecycle_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-lifecycle-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-location 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_bucket_location(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-location" }, input, callbacks)
end

--- AWS s3api get-bucket-logging 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_bucket_logging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-logging" }, input, callbacks)
end

--- AWS s3api get-bucket-metadata-table-configuration 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_bucket_metadata_table_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-metadata-table-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-metrics-configuration 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_bucket_metrics_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-metrics-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-notification-configuration 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_bucket_notification_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-notification-configuration" }, input, callbacks)
end

--- AWS s3api get-bucket-ownership-controls 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_bucket_ownership_controls(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-ownership-controls" }, input, callbacks)
end

--- AWS s3api get-bucket-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_bucket_policy(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-policy" }, input, callbacks)
end

--- AWS s3api get-bucket-policy-status 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_bucket_policy_status(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-policy-status" }, input, callbacks)
end

--- AWS s3api get-bucket-replication 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_bucket_replication(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-replication" }, input, callbacks)
end

--- AWS s3api get-bucket-request-payment 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_bucket_request_payment(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-request-payment" }, input, callbacks)
end

--- AWS s3api get-bucket-tagging 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_bucket_tagging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-tagging" }, input, callbacks)
end

--- AWS s3api get-bucket-versioning 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_bucket_versioning(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-versioning" }, input, callbacks)
end

--- AWS s3api get-bucket-website 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_bucket_website(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-bucket-website" }, input, callbacks)
end

--- AWS s3api get-object 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_object(input, callbacks)
	return common.execute_aws_command({ "s3api", "get-object" }, input, callbacks)
end

--- AWS s3api get-object-acl 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_object_acl(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-object-acl" }, input, callbacks)
end

--- AWS s3api get-object-attributes 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_object_attributes(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-object-attributes" }, input, callbacks)
end

--- AWS s3api get-object-legal-hold 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_object_legal_hold(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-object-legal-hold" }, input, callbacks)
end

--- AWS s3api get-object-lock-configuration 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_object_lock_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-object-lock-configuration" }, input, callbacks)
end

--- AWS s3api get-object-retention 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_object_retention(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-object-retention" }, input, callbacks)
end

--- AWS s3api get-object-tagging 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_object_tagging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-object-tagging" }, input, callbacks)
end

--- AWS s3api get-object-torrent 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_object_torrent(input, callbacks)
	return common.execute_aws_command({ "s3api", "get-object-torrent" }, input, callbacks)
end

--- AWS s3api get-public-access-block 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_public_access_block(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "get-public-access-block" }, input, callbacks)
end

--- AWS s3api head-bucket 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.head_bucket(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "head-bucket" }, input, callbacks)
end

--- AWS s3api head-object 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.head_object(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "head-object" }, input, callbacks)
end

--- AWS s3api list-bucket-analytics-configurations 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_bucket_analytics_configurations(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-bucket-analytics-configurations" }, input, callbacks)
end

--- AWS s3api list-bucket-intelligent-tiering-configurations 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_bucket_intelligent_tiering_configurations(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-bucket-intelligent-tiering-configurations" }, input, callbacks)
end

--- AWS s3api list-bucket-inventory-configurations 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_bucket_inventory_configurations(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-bucket-inventory-configurations" }, input, callbacks)
end

--- AWS s3api list-bucket-metrics-configurations 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_bucket_metrics_configurations(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-bucket-metrics-configurations" }, input, callbacks)
end

--- AWS s3api list-buckets 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_buckets(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-buckets" }, input, callbacks)
end

--- AWS s3api list-directory-buckets 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_directory_buckets(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-directory-buckets" }, input, callbacks)
end

--- AWS s3api list-multipart-uploads 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_multipart_uploads(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-multipart-uploads" }, input, callbacks)
end

--- AWS s3api list-object-versions 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_object_versions(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-object-versions" }, input, callbacks)
end

--- AWS s3api list-objects 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_objects(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-objects" }, input, callbacks)
end

--- AWS s3api list-objects-v2 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_objects_v2(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-objects-v2" }, input, callbacks)
end

--- AWS s3api list-parts 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_parts(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "list-parts" }, input, callbacks)
end

--- AWS s3api put-bucket-accelerate-configuration 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_bucket_accelerate_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-accelerate-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-acl 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_bucket_acl(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-acl" }, input, callbacks)
end

--- AWS s3api put-bucket-analytics-configuration 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_bucket_analytics_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-analytics-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-cors 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_bucket_cors(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-cors" }, input, callbacks)
end

--- AWS s3api put-bucket-encryption 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_bucket_encryption(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-encryption" }, input, callbacks)
end

--- AWS s3api put-bucket-intelligent-tiering-configuration 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_bucket_intelligent_tiering_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-intelligent-tiering-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-inventory-configuration 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_bucket_inventory_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-inventory-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-lifecycle-configuration 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_bucket_lifecycle_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-lifecycle-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-logging 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_bucket_logging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-logging" }, input, callbacks)
end

--- AWS s3api put-bucket-metrics-configuration 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_bucket_metrics_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-metrics-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-notification-configuration 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_bucket_notification_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-notification-configuration" }, input, callbacks)
end

--- AWS s3api put-bucket-ownership-controls 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_bucket_ownership_controls(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-ownership-controls" }, input, callbacks)
end

--- AWS s3api put-bucket-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_bucket_policy(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-policy" }, input, callbacks)
end

--- AWS s3api put-bucket-replication 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_bucket_replication(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-replication" }, input, callbacks)
end

--- AWS s3api put-bucket-request-payment 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_bucket_request_payment(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-request-payment" }, input, callbacks)
end

--- AWS s3api put-bucket-tagging 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_bucket_tagging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-tagging" }, input, callbacks)
end

--- AWS s3api put-bucket-versioning 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_bucket_versioning(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-versioning" }, input, callbacks)
end

--- AWS s3api put-bucket-website 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_bucket_website(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-bucket-website" }, input, callbacks)
end

--- AWS s3api put-object 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_object(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-object" }, input, callbacks)
end

--- AWS s3api put-object-acl 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_object_acl(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-object-acl" }, input, callbacks)
end

--- AWS s3api put-object-legal-hold 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_object_legal_hold(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-object-legal-hold" }, input, callbacks)
end

--- AWS s3api put-object-lock-configuration 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_object_lock_configuration(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-object-lock-configuration" }, input, callbacks)
end

--- AWS s3api put-object-retention 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_object_retention(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-object-retention" }, input, callbacks)
end

--- AWS s3api put-object-tagging 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_object_tagging(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-object-tagging" }, input, callbacks)
end

--- AWS s3api put-public-access-block 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_public_access_block(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "put-public-access-block" }, input, callbacks)
end

--- AWS s3api restore-object 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_object(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "restore-object" }, input, callbacks)
end

--- AWS s3api select-object-content 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.select_object_content(input, callbacks)
	return common.execute_aws_command({ "s3api", "select-object-content" }, input, callbacks)
end

--- AWS s3api upload-part 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.upload_part(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "upload-part" }, input, callbacks)
end

--- AWS s3api upload-part-copy 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.upload_part_copy(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "upload-part-copy" }, input, callbacks)
end

--- AWS s3api 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({ "s3api", "wait" }, input, callbacks)
end

--- AWS s3api write-get-object-response 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.write_get_object_response(input, callbacks)
	return common.execute_aws_command_skeleton({ "s3api", "write-get-object-response" }, input, callbacks)
end

return M
