dropbox_sdk/generated/sync_routes/

files.rs

// DO NOT EDIT
// This file was @generated by Stone

#![allow(
    clippy::too_many_arguments,
    clippy::large_enum_variant,
    clippy::result_large_err,
    clippy::doc_markdown,
    clippy::doc_lazy_continuation,
)]

#[allow(unused_imports)]
pub use crate::generated::types::files::*;

/// Returns the metadata for a file or folder. This is an alpha endpoint compatible with the
/// properties API. Note: Metadata for the root folder is unsupported.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
#[deprecated]
pub fn alpha_get_metadata(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &AlphaGetMetadataArg,
) -> Result<Metadata, crate::Error<AlphaGetMetadataError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/alpha/get_metadata",
            arg,
            None)
    )
}

/// Create a new file with the contents provided in the request. Note that the behavior of this
/// alpha endpoint is unstable and subject to change. Do not use this to upload a file larger than
/// 150 MiB. Instead, create an upload session with
/// [`upload_session_start()`](crate::files::upload_session_start).
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
#[deprecated]
pub fn alpha_upload(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadArg,
    body: &[u8],
) -> Result<FileMetadata, crate::Error<UploadError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/alpha/upload",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Copy a file or folder to a different location in the user's Dropbox. If the source path is a
/// folder all its contents will be copied.
#[deprecated]
pub fn copy(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RelocationArg,
) -> Result<Metadata, crate::Error<RelocationError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy",
            arg,
            None)
    )
}

/// Copy a file or folder to a different location in the user's Dropbox. If the source path is a
/// folder all its contents will be copied.
pub fn copy_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RelocationArg,
) -> Result<RelocationResult, crate::Error<RelocationError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_v2",
            arg,
            None)
    )
}

/// Copy multiple files or folders to different locations at once in the user's Dropbox. This route
/// will return job ID immediately and do the async copy job in background. Please use
/// [`copy_batch_check()`](crate::files::copy_batch_check) to check the job status.
#[deprecated]
pub fn copy_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RelocationBatchArg,
) -> Result<RelocationBatchLaunch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_batch",
            arg,
            None)
    )
}

/// Copy multiple files or folders to different locations at once in the user's Dropbox. This route
/// will replace [`copy_batch()`](crate::files::copy_batch). The main difference is this route will
/// return status for each entry, while [`copy_batch()`](crate::files::copy_batch) raises failure if
/// any entry fails. This route will either finish synchronously, or return a job ID and do the
/// async copy job in background. Please use
/// [`copy_batch_check_v2()`](crate::files::copy_batch_check_v2) to check the job status.
pub fn copy_batch_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &CopyBatchArg,
) -> Result<RelocationBatchV2Launch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_batch_v2",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for [`copy_batch()`](crate::files::copy_batch). If
/// success, it returns list of results for each entry.
#[deprecated]
pub fn copy_batch_check(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<RelocationBatchJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_batch/check",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for [`copy_batch_v2()`](crate::files::copy_batch_v2).
/// It returns list of results for each entry.
pub fn copy_batch_check_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<RelocationBatchV2JobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_batch/check_v2",
            arg,
            None)
    )
}

/// Get a copy reference to a file or folder. This reference string can be used to save that file or
/// folder to another user's Dropbox by passing it to
/// [`copy_reference_save()`](crate::files::copy_reference_save).
pub fn copy_reference_get(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &GetCopyReferenceArg,
) -> Result<GetCopyReferenceResult, crate::Error<GetCopyReferenceError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_reference/get",
            arg,
            None)
    )
}

/// Save a copy reference returned by [`copy_reference_get()`](crate::files::copy_reference_get) to
/// the user's Dropbox.
pub fn copy_reference_save(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &SaveCopyReferenceArg,
) -> Result<SaveCopyReferenceResult, crate::Error<SaveCopyReferenceError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/copy_reference/save",
            arg,
            None)
    )
}

/// Create a folder at a given path.
#[deprecated]
pub fn create_folder(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &CreateFolderArg,
) -> Result<FolderMetadata, crate::Error<CreateFolderError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/create_folder",
            arg,
            None)
    )
}

/// Create a folder at a given path.
pub fn create_folder_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &CreateFolderArg,
) -> Result<CreateFolderResult, crate::Error<CreateFolderError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/create_folder_v2",
            arg,
            None)
    )
}

/// Create multiple folders at once. This route is asynchronous for large batches, which returns a
/// job ID immediately and runs the create folder batch asynchronously. Otherwise, creates the
/// folders and returns the result synchronously for smaller inputs. You can force asynchronous
/// behaviour by using the CreateFolderBatchArg.force_async flag.  Use
/// [`create_folder_batch_check()`](crate::files::create_folder_batch_check) to check the job
/// status.
pub fn create_folder_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &CreateFolderBatchArg,
) -> Result<CreateFolderBatchLaunch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/create_folder_batch",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for
/// [`create_folder_batch()`](crate::files::create_folder_batch). If success, it returns list of
/// result for each entry.
pub fn create_folder_batch_check(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<CreateFolderBatchJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/create_folder_batch/check",
            arg,
            None)
    )
}

/// Delete the file or folder at a given path. If the path is a folder, all its contents will be
/// deleted too. A successful response indicates that the file or folder was deleted. The returned
/// metadata will be the corresponding FileMetadata or FolderMetadata for the item at time of
/// deletion, and not a DeletedMetadata object.
#[deprecated]
pub fn delete(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &DeleteArg,
) -> Result<Metadata, crate::Error<DeleteError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/delete",
            arg,
            None)
    )
}

/// Delete the file or folder at a given path. If the path is a folder, all its contents will be
/// deleted too. A successful response indicates that the file or folder was deleted. The returned
/// metadata will be the corresponding FileMetadata or FolderMetadata for the item at time of
/// deletion, and not a DeletedMetadata object.
pub fn delete_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &DeleteArg,
) -> Result<DeleteResult, crate::Error<DeleteError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/delete_v2",
            arg,
            None)
    )
}

/// Delete multiple files/folders at once. This route is asynchronous, which returns a job ID
/// immediately and runs the delete batch asynchronously. Use
/// [`delete_batch_check()`](crate::files::delete_batch_check) to check the job status.
pub fn delete_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &DeleteBatchArg,
) -> Result<DeleteBatchLaunch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/delete_batch",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for [`delete_batch()`](crate::files::delete_batch). If
/// success, it returns list of result for each entry.
pub fn delete_batch_check(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<DeleteBatchJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/delete_batch/check",
            arg,
            None)
    )
}

/// Download a file from a user's Dropbox.
pub fn download(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &DownloadArg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<FileMetadata>, crate::Error<DownloadError>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/download",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Download a folder from the user's Dropbox, as a zip file. The folder must be less than 20 GB in
/// size and any single file within must be less than 4 GB in size. The resulting zip must have
/// fewer than 10,000 total file and folder entries, including the top level folder. The input
/// cannot be a single file. Note: this endpoint does not support HTTP range requests.
pub fn download_zip(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &DownloadZipArg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<DownloadZipResult>, crate::Error<DownloadZipError>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/download_zip",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Export a file from a user's Dropbox. This route only supports exporting files that cannot be
/// downloaded directly and whose ExportResult.file_metadata has ExportInfo.export_as populated.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn export(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ExportArg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<ExportResult>, crate::Error<ExportError>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/export",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Return the lock metadata for the given list of paths.
pub fn get_file_lock_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &LockFileBatchArg,
) -> Result<LockFileBatchResult, crate::Error<LockFileError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/get_file_lock_batch",
            arg,
            None)
    )
}

/// Returns the metadata for a file or folder. Note: Metadata for the root folder is unsupported.
pub fn get_metadata(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &GetMetadataArg,
) -> Result<Metadata, crate::Error<GetMetadataError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/get_metadata",
            arg,
            None)
    )
}

/// Get a preview for a file. Currently, PDF previews are generated for files with the following
/// extensions: .ai, .doc, .docm, .docx, .eps, .gdoc, .gslides, .odp, .odt, .pps, .ppsm, .ppsx,
/// .ppt, .pptm, .pptx, .rtf. HTML previews are generated for .csv, .ods, .xls, .xlsm, .gsheet,
/// .xlsx. Other formats will return an unsupported extension error.
pub fn get_preview(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &PreviewArg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<FileMetadata>, crate::Error<PreviewError>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/get_preview",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Get a temporary link to stream content of a file. This link will expire in four hours and
/// afterwards you will get 410 Gone. This URL should not be used to display content directly in the
/// browser. The Content-Type of the link is determined automatically by the file's mime type.
pub fn get_temporary_link(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &GetTemporaryLinkArg,
) -> Result<GetTemporaryLinkResult, crate::Error<GetTemporaryLinkError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/get_temporary_link",
            arg,
            None)
    )
}

/// Get a one-time use temporary upload link to upload a file to a Dropbox location.  This endpoint
/// acts as a delayed upload(). The returned temporary upload link may be used to make a POST
/// request with the data to be uploaded. The upload will then be perfomed with the CommitInfo
/// previously provided to getTemporaryUploadLink() but evaluated only upon consumption. Hence,
/// errors stemming from invalid CommitInfo with respect to the state of the user's Dropbox will
/// only be communicated at consumption time. Additionally, these errors are surfaced as generic
/// HTTP 409 Conflict responses, potentially hiding issue details. The maximum temporary upload link
/// duration is 4 hours. Upon consumption or expiration, a new link will have to be generated.
/// Multiple links may exist for a specific upload path at any given time.  The POST request on the
/// temporary upload link must have its Content-Type set to "application/octet-stream".  Example
/// temporary upload link consumption request:  curl -X POST
/// https://content.dropboxapi.com/apitul/1/bNi2uIYF51cVBND --header "Content-Type:
/// application/octet-stream" --data-binary @local_file.txt  A successful temporary upload link
/// consumption request returns the content hash of the uploaded data in JSON format. Example
/// successful temporary upload link consumption response: {"content-hash":
/// "599d71033d700ac892a0e48fa61b125d2f5994"}  An unsuccessful temporary upload link consumption
/// request returns any of the following status codes:  HTTP 400 Bad Request: Content-Type is not
/// one of application/octet-stream and text/plain or request is invalid. HTTP 409 Conflict: The
/// temporary upload link does not exist or is currently unavailable, the upload failed, or another
/// error happened. HTTP 410 Gone: The temporary upload link is expired or consumed. Example
/// unsuccessful temporary upload link consumption response: Temporary upload link has been recently
/// consumed.
pub fn get_temporary_upload_link(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &GetTemporaryUploadLinkArg,
) -> Result<GetTemporaryUploadLinkResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/get_temporary_upload_link",
            arg,
            None)
    )
}

/// Get a thumbnail for an image. This method currently supports files with the following file
/// extensions: jpg, jpeg, png, tiff, tif, gif, webp, ppm and bmp. Photos that are larger than 20MB
/// in size won't be converted to a thumbnail.
pub fn get_thumbnail(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ThumbnailArg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<FileMetadata>, crate::Error<ThumbnailError>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/get_thumbnail",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Get a thumbnail for an image. This method currently supports files with the following file
/// extensions: jpg, jpeg, png, tiff, tif, gif, webp, ppm and bmp. Photos that are larger than 20MB
/// in size won't be converted to a thumbnail.
pub fn get_thumbnail_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ThumbnailV2Arg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<PreviewResult>, crate::Error<ThumbnailV2Error>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/get_thumbnail_v2",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Get a thumbnail for an image. This method currently supports files with the following file
/// extensions: jpg, jpeg, png, tiff, tif, gif, webp, ppm and bmp. Photos that are larger than 20MB
/// in size won't be converted to a thumbnail.
pub fn get_thumbnail_v2_app_auth(
    client: &impl crate::client_trait::AppAuthClient,
    arg: &ThumbnailV2Arg,
    range_start: Option<u64>,
    range_end: Option<u64>,
) -> Result<crate::client_trait::HttpRequestResult<PreviewResult>, crate::Error<ThumbnailV2Error>> {
    crate::client_helpers::unwrap_async_body(
        crate::client_helpers::request_with_body(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Download,
            "files/get_thumbnail_v2",
            arg,
            None,
            range_start,
            range_end),
        client,
    )
}

/// Get thumbnails for a list of images. We allow up to 25 thumbnails in a single batch. This method
/// currently supports files with the following file extensions: jpg, jpeg, png, tiff, tif, gif,
/// webp, ppm and bmp. Photos that are larger than 20MB in size won't be converted to a thumbnail.
pub fn get_thumbnail_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &GetThumbnailBatchArg,
) -> Result<GetThumbnailBatchResult, crate::Error<GetThumbnailBatchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Rpc,
            "files/get_thumbnail_batch",
            arg,
            None)
    )
}

/// Starts returning the contents of a folder. If the result's
/// [`ListFolderResult::has_more`](ListFolderResult) field is true, call
/// [`list_folder_continue()`](crate::files::list_folder_continue) with the returned
/// ListFolderResult.cursor to retrieve more entries. If you're using ListFolderArg.recursive set to
/// true to keep a local cache of the contents of a Dropbox account, iterate through each entry in
/// order and process them as follows to keep your local state in sync: For each FileMetadata, store
/// the new entry at the given path in your local state. If the required parent folders don't exist
/// yet, create them. If there's already something else at the given path, replace it and remove all
/// its children. For each FolderMetadata, store the new entry at the given path in your local
/// state. If the required parent folders don't exist yet, create them. If there's already something
/// else at the given path, replace it but leave the children as they are. Check the new entry's
/// FolderSharingInfo.read_only and set all its children's read-only statuses to match. For each
/// DeletedMetadata, if your local state has something at the given path, remove it and all its
/// children. If there's nothing at the given path, ignore this entry. Note: auth.RateLimitError may
/// be returned if multiple [`list_folder()`](crate::files::list_folder) or
/// [`list_folder_continue()`](crate::files::list_folder_continue) calls with same parameters are
/// made simultaneously by same API app for same user. If your app implements retry logic, please
/// hold off the retry until the previous request finishes.
pub fn list_folder(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ListFolderArg,
) -> Result<ListFolderResult, crate::Error<ListFolderError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/list_folder",
            arg,
            None)
    )
}

/// Starts returning the contents of a folder. If the result's
/// [`ListFolderResult::has_more`](ListFolderResult) field is true, call
/// [`list_folder_continue()`](crate::files::list_folder_continue) with the returned
/// ListFolderResult.cursor to retrieve more entries. If you're using ListFolderArg.recursive set to
/// true to keep a local cache of the contents of a Dropbox account, iterate through each entry in
/// order and process them as follows to keep your local state in sync: For each FileMetadata, store
/// the new entry at the given path in your local state. If the required parent folders don't exist
/// yet, create them. If there's already something else at the given path, replace it and remove all
/// its children. For each FolderMetadata, store the new entry at the given path in your local
/// state. If the required parent folders don't exist yet, create them. If there's already something
/// else at the given path, replace it but leave the children as they are. Check the new entry's
/// FolderSharingInfo.read_only and set all its children's read-only statuses to match. For each
/// DeletedMetadata, if your local state has something at the given path, remove it and all its
/// children. If there's nothing at the given path, ignore this entry. Note: auth.RateLimitError may
/// be returned if multiple [`list_folder()`](crate::files::list_folder) or
/// [`list_folder_continue()`](crate::files::list_folder_continue) calls with same parameters are
/// made simultaneously by same API app for same user. If your app implements retry logic, please
/// hold off the retry until the previous request finishes.
pub fn list_folder_app_auth(
    client: &impl crate::client_trait::AppAuthClient,
    arg: &ListFolderArg,
) -> Result<ListFolderResult, crate::Error<ListFolderError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/list_folder",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`list_folder()`](crate::files::list_folder), use this to
/// paginate through all files and retrieve updates to the folder, following the same rules as
/// documented for [`list_folder()`](crate::files::list_folder).
pub fn list_folder_continue(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ListFolderContinueArg,
) -> Result<ListFolderResult, crate::Error<ListFolderContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/list_folder/continue",
            arg,
            None)
    )
}

/// Once a cursor has been retrieved from [`list_folder()`](crate::files::list_folder), use this to
/// paginate through all files and retrieve updates to the folder, following the same rules as
/// documented for [`list_folder()`](crate::files::list_folder).
pub fn list_folder_continue_app_auth(
    client: &impl crate::client_trait::AppAuthClient,
    arg: &ListFolderContinueArg,
) -> Result<ListFolderResult, crate::Error<ListFolderContinueError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/list_folder/continue",
            arg,
            None)
    )
}

/// A way to quickly get a cursor for the folder's state. Unlike
/// [`list_folder()`](crate::files::list_folder),
/// [`list_folder_get_latest_cursor()`](crate::files::list_folder_get_latest_cursor) doesn't return
/// any entries. This endpoint is for app which only needs to know about new files and modifications
/// and doesn't need to know about files that already exist in Dropbox.
pub fn list_folder_get_latest_cursor(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ListFolderArg,
) -> Result<ListFolderGetLatestCursorResult, crate::Error<ListFolderError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/list_folder/get_latest_cursor",
            arg,
            None)
    )
}

/// A longpoll endpoint to wait for changes on an account. In conjunction with
/// [`list_folder_continue()`](crate::files::list_folder_continue), this call gives you a
/// low-latency way to monitor an account for file changes. The connection will block until there
/// are changes available or a timeout occurs. This endpoint is useful mostly for client-side apps.
pub fn list_folder_longpoll(
    client: &impl crate::client_trait::NoauthClient,
    arg: &ListFolderLongpollArg,
) -> Result<ListFolderLongpollResult, crate::Error<ListFolderLongpollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Notify,
            crate::client_trait_common::Style::Rpc,
            "files/list_folder/longpoll",
            arg,
            None)
    )
}

/// Returns revisions for files based on a file path or a file id. The file path or file id is
/// identified from the latest file entry at the given file path or id. This end point allows your
/// app to query either by file path or file id by setting the mode parameter appropriately. In the
/// ListRevisionsMode.path (default) mode, all revisions at the same file path as the latest file
/// entry are returned. If revisions with the same file id are desired, then mode must be set to
/// ListRevisionsMode.id. The ListRevisionsMode.id mode is useful to retrieve revisions for a given
/// file across moves or renames.
pub fn list_revisions(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &ListRevisionsArg,
) -> Result<ListRevisionsResult, crate::Error<ListRevisionsError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/list_revisions",
            arg,
            None)
    )
}

/// Lock the files at the given paths. A locked file will be writable only by the lock holder. A
/// successful response indicates that the file has been locked. Returns a list of the locked file
/// paths and their metadata after this operation.
pub fn lock_file_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &LockFileBatchArg,
) -> Result<LockFileBatchResult, crate::Error<LockFileError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/lock_file_batch",
            arg,
            None)
    )
}

/// Move a file or folder to a different location in the user's Dropbox. If the source path is a
/// folder all its contents will be moved.
#[deprecated]
pub fn do_move(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RelocationArg,
) -> Result<Metadata, crate::Error<RelocationError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/move",
            arg,
            None)
    )
}

/// Move a file or folder to a different location in the user's Dropbox. If the source path is a
/// folder all its contents will be moved. Note that we do not currently support case-only renaming.
pub fn move_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RelocationArg,
) -> Result<RelocationResult, crate::Error<RelocationError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/move_v2",
            arg,
            None)
    )
}

/// Move multiple files or folders to different locations at once in the user's Dropbox. This route
/// will return job ID immediately and do the async moving job in background. Please use
/// [`move_batch_check()`](crate::files::move_batch_check) to check the job status.
#[deprecated]
pub fn move_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RelocationBatchArg,
) -> Result<RelocationBatchLaunch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/move_batch",
            arg,
            None)
    )
}

/// Move multiple files or folders to different locations at once in the user's Dropbox. Note that
/// we do not currently support case-only renaming. This route will replace
/// [`move_batch()`](crate::files::move_batch). The main difference is this route will return status
/// for each entry, while [`move_batch()`](crate::files::move_batch) raises failure if any entry
/// fails. This route will either finish synchronously, or return a job ID and do the async move job
/// in background. Please use [`move_batch_check_v2()`](crate::files::move_batch_check_v2) to check
/// the job status.
pub fn move_batch_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &MoveBatchArg,
) -> Result<RelocationBatchV2Launch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/move_batch_v2",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for [`move_batch()`](crate::files::move_batch). If
/// success, it returns list of results for each entry.
#[deprecated]
pub fn move_batch_check(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<RelocationBatchJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/move_batch/check",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for [`move_batch_v2()`](crate::files::move_batch_v2).
/// It returns list of results for each entry.
pub fn move_batch_check_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<RelocationBatchV2JobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/move_batch/check_v2",
            arg,
            None)
    )
}

/// Creates a new Paper doc with the provided content.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn paper_create(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &PaperCreateArg,
    body: &[u8],
) -> Result<PaperCreateResult, crate::Error<PaperCreateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Upload,
            "files/paper/create",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Updates an existing Paper doc with the provided content.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn paper_update(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &PaperUpdateArg,
    body: &[u8],
) -> Result<PaperUpdateResult, crate::Error<PaperUpdateError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Upload,
            "files/paper/update",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Permanently delete the file or folder at a given path (see https://www.dropbox.com/en/help/40).
/// If the given file or folder is not yet deleted, this route will first delete it. It is possible
/// for this route to successfully delete, then fail to permanently delete. Note: This endpoint is
/// only available for Dropbox Business apps.
pub fn permanently_delete(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &DeleteArg,
) -> Result<(), crate::Error<DeleteError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/permanently_delete",
            arg,
            None)
    )
}

/// Add property groups to a Dropbox file. See templates/add_for_user or templates/add_for_team to
/// create new templates.
#[deprecated]
pub fn properties_add(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::file_properties::AddPropertiesArg,
) -> Result<(), crate::Error<crate::types::file_properties::AddPropertiesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/properties/add",
            arg,
            None)
    )
}

/// Overwrite property groups associated with a file. This endpoint should be used instead of
/// properties/update when property groups are being overwritten rather than updated via a "delta".
#[deprecated]
pub fn properties_overwrite(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::file_properties::OverwritePropertyGroupArg,
) -> Result<(), crate::Error<crate::types::file_properties::InvalidPropertyGroupError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/properties/overwrite",
            arg,
            None)
    )
}

/// Add, update or remove properties associated with the supplied file and templates. This endpoint
/// should be used instead of properties/overwrite when property groups are being updated via a
/// "delta" instead of overwriting all properties of a file.
#[deprecated]
pub fn properties_update(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::file_properties::UpdatePropertiesArg,
) -> Result<(), crate::Error<crate::types::file_properties::UpdatePropertiesError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/properties/update",
            arg,
            None)
    )
}

/// Restore a specific revision of a file to the given path.
pub fn restore(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RestoreArg,
) -> Result<FileMetadata, crate::Error<RestoreError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/restore",
            arg,
            None)
    )
}

/// Save the data from a specified URL into a file in user's Dropbox. Note that the transfer from
/// the URL must complete within 15 minutes, or the operation will time out and the job will fail.
pub fn save_url(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &SaveUrlArg,
) -> Result<SaveUrlResult, crate::Error<SaveUrlError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/save_url",
            arg,
            None)
    )
}

/// Check the status of a [`save_url()`](crate::files::save_url) job.
pub fn save_url_check_job_status(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<SaveUrlJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/save_url/check_job_status",
            arg,
            None)
    )
}

/// Searches for files and folders. Note: Recent changes will be reflected in search results within
/// a few seconds and older revisions of existing files may still match your query for up to a few
/// days.
#[deprecated]
pub fn search(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &SearchArg,
) -> Result<SearchResult, crate::Error<SearchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/search",
            arg,
            None)
    )
}

/// Searches for files and folders. Note: [`search_v2()`](crate::files::search_v2) along with
/// [`search_continue_v2()`](crate::files::search_continue_v2) can only be used to retrieve a
/// maximum of 10,000 matches. Recent changes may not immediately be reflected in search results due
/// to a short delay in indexing. Duplicate results may be returned across pages. Some results may
/// not be returned.
pub fn search_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &SearchV2Arg,
) -> Result<SearchV2Result, crate::Error<SearchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/search_v2",
            arg,
            None)
    )
}

/// Fetches the next page of search results returned from [`search_v2()`](crate::files::search_v2).
/// Note: [`search_v2()`](crate::files::search_v2) along with
/// [`search_continue_v2()`](crate::files::search_continue_v2) can only be used to retrieve a
/// maximum of 10,000 matches. Recent changes may not immediately be reflected in search results due
/// to a short delay in indexing. Duplicate results may be returned across pages. Some results may
/// not be returned.
pub fn search_continue_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &SearchV2ContinueArg,
) -> Result<SearchV2Result, crate::Error<SearchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/search/continue_v2",
            arg,
            None)
    )
}

/// Add a tag to an item. A tag is a string. The strings are automatically converted to lowercase
/// letters. No more than 20 tags can be added to a given item.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn tags_add(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &AddTagArg,
) -> Result<(), crate::Error<AddTagError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/tags/add",
            arg,
            None)
    )
}

/// Get list of tags assigned to items.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn tags_get(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &GetTagsArg,
) -> Result<GetTagsResult, crate::Error<BaseTagError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/tags/get",
            arg,
            None)
    )
}

/// Remove a tag from an item.
///
/// # Stability
/// *PREVIEW*: This function may change or disappear without notice.
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn tags_remove(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &RemoveTagArg,
) -> Result<(), crate::Error<RemoveTagError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/tags/remove",
            arg,
            None)
    )
}

/// Unlock the files at the given paths. A locked file can only be unlocked by the lock holder or,
/// if a business account, a team admin. A successful response indicates that the file has been
/// unlocked. Returns a list of the unlocked file paths and their metadata after this operation.
pub fn unlock_file_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UnlockFileBatchArg,
) -> Result<LockFileBatchResult, crate::Error<LockFileError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/unlock_file_batch",
            arg,
            None)
    )
}

/// Create a new file with the contents provided in the request. Do not use this to upload a file
/// larger than 150 MiB. Instead, create an upload session with
/// [`upload_session_start()`](crate::files::upload_session_start). Calls to this endpoint will
/// count as data transport calls for any Dropbox Business teams with a limit on the number of data
/// transport calls allowed per month. For more information, see the Data transport limit page
/// https://www.dropbox.com/developers/reference/data-transport-limit.
pub fn upload(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadArg,
    body: &[u8],
) -> Result<FileMetadata, crate::Error<UploadError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/upload",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Append more data to an upload session. A single request should not upload more than 150 MiB. The
/// maximum size of a file one can upload to an upload session is 2^41 - 2^22 (2,199,019,061,248)
/// bytes. Calls to this endpoint will count as data transport calls for any Dropbox Business teams
/// with a limit on the number of data transport calls allowed per month. For more information, see
/// the Data transport limit page https://www.dropbox.com/developers/reference/data-transport-limit.
#[deprecated]
pub fn upload_session_append(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionCursor,
    body: &[u8],
) -> Result<(), crate::Error<UploadSessionAppendError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/upload_session/append",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Append more data to an upload session. When the parameter close is set, this call will close the
/// session. A single request should not upload more than 150 MiB. The maximum size of a file one
/// can upload to an upload session is 2^41 - 2^22 (2,199,019,061,248) bytes. Calls to this endpoint
/// will count as data transport calls for any Dropbox Business teams with a limit on the number of
/// data transport calls allowed per month. For more information, see the Data transport limit page
/// https://www.dropbox.com/developers/reference/data-transport-limit.
pub fn upload_session_append_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionAppendArg,
    body: &[u8],
) -> Result<(), crate::Error<UploadSessionAppendError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/upload_session/append_v2",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Append more data to multiple upload sessions. Each piece of file content to append to each
/// upload session should be concatenated in the request body, in the order delineated by
/// [`UploadSessionAppendBatchArg::entries`](UploadSessionAppendBatchArg) and their individual
/// lengths indicated by
/// [`UploadSessionAppendBatchArgEntry::length`](UploadSessionAppendBatchArgEntry). A single request
/// should not upload more than 150 MiB. The maximum size of a file one can upload to an upload
/// session is 2^41 - 2^22 (2,199,019,061,248) bytes. Calls to this endpoint will count as data
/// transport calls for any Dropbox Business teams with a limit on the number of data transport
/// calls allowed per month. For more information, see the Data transport limit page
/// https://www.dropbox.com/developers/reference/data-transport-limit.
pub fn upload_session_append_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionAppendBatchArg,
    body: &[u8],
) -> Result<UploadSessionAppendBatchResult, crate::Error<UploadSessionAppendBatchError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/upload_session/append_batch",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Finish an upload session and save the uploaded data to the given file path. A single request
/// should not upload more than 150 MiB. The maximum size of a file one can upload to an upload
/// session is 2^41 - 2^22 (2,199,019,061,248) bytes. Calls to this endpoint will count as data
/// transport calls for any Dropbox Business teams with a limit on the number of data transport
/// calls allowed per month. For more information, see the Data transport limit page
/// https://www.dropbox.com/developers/reference/data-transport-limit.
pub fn upload_session_finish(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionFinishArg,
    body: &[u8],
) -> Result<FileMetadata, crate::Error<UploadSessionFinishError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/upload_session/finish",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// This route helps you commit many files at once into a user's Dropbox. Use
/// [`upload_session_start()`](crate::files::upload_session_start) and
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) to upload file contents.
/// We recommend uploading many files in parallel to increase throughput. Once the file contents
/// have been uploaded, rather than calling
/// [`upload_session_finish()`](crate::files::upload_session_finish), use this route to finish all
/// your upload sessions in a single request.
/// [`UploadSessionStartArg::close`](UploadSessionStartArg) or
/// [`UploadSessionAppendArg::close`](UploadSessionAppendArg) needs to be true for the last
/// [`upload_session_start()`](crate::files::upload_session_start) or
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) call. The maximum size of
/// a file one can upload to an upload session is 2^41 - 2^22 (2,199,019,061,248) bytes. This route
/// will return a job_id immediately and do the async commit job in background. Use
/// [`upload_session_finish_batch_check()`](crate::files::upload_session_finish_batch_check) to
/// check the job status. For the same account, this route should be executed serially. That means
/// you should not start the next job before current job finishes. We allow up to 1000 entries in a
/// single request. Calls to this endpoint will count as data transport calls for any Dropbox
/// Business teams with a limit on the number of data transport calls allowed per month. For more
/// information, see the Data transport limit page
/// https://www.dropbox.com/developers/reference/data-transport-limit.
#[deprecated]
pub fn upload_session_finish_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionFinishBatchArg,
) -> Result<UploadSessionFinishBatchLaunch, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/upload_session/finish_batch",
            arg,
            None)
    )
}

/// This route helps you commit many files at once into a user's Dropbox. Use
/// [`upload_session_start()`](crate::files::upload_session_start) and
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) to upload file contents.
/// We recommend uploading many files in parallel to increase throughput. Once the file contents
/// have been uploaded, rather than calling
/// [`upload_session_finish()`](crate::files::upload_session_finish), use this route to finish all
/// your upload sessions in a single request.
/// [`UploadSessionStartArg::close`](UploadSessionStartArg) or
/// [`UploadSessionAppendArg::close`](UploadSessionAppendArg) needs to be true for the last
/// [`upload_session_start()`](crate::files::upload_session_start) or
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) call of each upload
/// session. The maximum size of a file one can upload to an upload session is 2^41 - 2^22
/// (2,199,019,061,248) bytes. We allow up to 1000 entries in a single request. Calls to this
/// endpoint will count as data transport calls for any Dropbox Business teams with a limit on the
/// number of data transport calls allowed per month. For more information, see the Data transport
/// limit page https://www.dropbox.com/developers/reference/data-transport-limit.
pub fn upload_session_finish_batch_v2(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionFinishBatchArg,
) -> Result<UploadSessionFinishBatchResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/upload_session/finish_batch_v2",
            arg,
            None)
    )
}

/// Returns the status of an asynchronous job for
/// [`upload_session_finish_batch()`](crate::files::upload_session_finish_batch). If success, it
/// returns list of result for each entry.
pub fn upload_session_finish_batch_check(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &crate::types::dbx_async::PollArg,
) -> Result<UploadSessionFinishBatchJobStatus, crate::Error<crate::types::dbx_async::PollError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/upload_session/finish_batch/check",
            arg,
            None)
    )
}

/// Upload sessions allow you to upload a single file in one or more requests, for example where the
/// size of the file is greater than 150 MiB. This call starts a new upload session with the given
/// data. You can then use [`upload_session_append_v2()`](crate::files::upload_session_append_v2) or
/// [`upload_session_append_batch()`](crate::files::upload_session_append_batch) to add more data,
/// then [`upload_session_finish()`](crate::files::upload_session_finish) or
/// [`upload_session_finish_batch_v2()`](crate::files::upload_session_finish_batch_v2) to save all
/// the data to a file in Dropbox. A single request should not upload more than 150 MiB. The maximum
/// size of a file one can upload to an upload session is 2^41 - 2^22 (2,199,019,061,248) bytes. An
/// upload session can be used for a maximum of 7 days. Attempting to use a
/// [`UploadSessionStartResult::session_id`](UploadSessionStartResult) with
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) or other upload session
/// routes more than 7 days after its creation will return [`UploadSessionLookupError::NotFound`].
/// Calls to this endpoint will count as data transport calls for any Dropbox Business teams with a
/// limit on the number of data transport calls allowed per month. For more information, see the
/// Data transport limit page https://www.dropbox.com/developers/reference/data-transport-limit. By
/// default, upload sessions require you to send content of the file in sequential order via
/// consecutive [`upload_session_start()`](crate::files::upload_session_start),
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2), and
/// [`upload_session_finish()`](crate::files::upload_session_finish) calls (or their batch
/// variants). For better performance, you can optionally set
/// [`UploadSessionStartArg::session_type`](UploadSessionStartArg) to
/// [`UploadSessionType::Concurrent`] to start a concurrent upload session. Concurrent upload
/// sessions may upload file data in concurrent
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) requests, with a few
/// caveats. After all of the requests are complete, finish the session with
/// [`upload_session_finish()`](crate::files::upload_session_finish) as normal. You can not send
/// data in a [`upload_session_start()`](crate::files::upload_session_start) or
/// [`upload_session_finish()`](crate::files::upload_session_finish) call, only with
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) or
/// [`upload_session_append_batch()`](crate::files::upload_session_append_batch). Also, the length
/// of the uploaded data in a call to
/// [`upload_session_append_v2()`](crate::files::upload_session_append_v2) or
/// [`upload_session_append_batch()`](crate::files::upload_session_append_batch) must be a multiple
/// of 2^22 (4,194,304) bytes, except for the final append request with
/// [`UploadSessionAppendArg::close`](UploadSessionAppendArg) or
/// [`UploadSessionAppendBatchArgEntry::close`](UploadSessionAppendBatchArgEntry) set to true that
/// may contain any remaining data.
pub fn upload_session_start(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionStartArg,
    body: &[u8],
) -> Result<UploadSessionStartResult, crate::Error<UploadSessionStartError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Content,
            crate::client_trait_common::Style::Upload,
            "files/upload_session/start",
            arg,
            Some(crate::client_helpers::Body::from(body)))
    )
}

/// Start a batch of upload sessions. See
/// [`upload_session_start()`](crate::files::upload_session_start). Calls to this endpoint will
/// count as data transport calls for any Dropbox Business teams with a limit on the number of data
/// transport calls allowed per month. For more information, see the Data transport limit page
/// https://www.dropbox.com/developers/reference/data-transport-limit.
pub fn upload_session_start_batch(
    client: &impl crate::client_trait::UserAuthClient,
    arg: &UploadSessionStartBatchArg,
) -> Result<UploadSessionStartBatchResult, crate::Error<crate::NoError>> {
    crate::client_helpers::unwrap_async(
        crate::client_helpers::request(
            client,
            crate::client_trait_common::Endpoint::Api,
            crate::client_trait_common::Style::Rpc,
            "files/upload_session/start_batch",
            arg,
            None)
    )
}