types.d.ts

/**
 * This file was auto-generated by openapi-typescript.
 * Do not make direct changes to the file.
 */

export interface paths {
    "/rc/noop": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Echo request parameters
         * @description Returns all supplied parameters unchanged so you can verify RC connectivity.
         */
        post: operations["rcNoop"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/cleanup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Remove trashed files
         * @description Permanently removes trashed objects from the specified remote path.
         */
        post: operations["operationsCleanup"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/copyfile": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Copy a single file
         * @description Copies one object from a source remote and path to a destination remote and path.
         */
        post: operations["operationsCopyfile"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/copyurl": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Copy from URL
         * @description Downloads a public URL and stores it at the requested remote path.
         */
        post: operations["operationsCopyurl"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete objects in path
         * @description Deletes matching files and directories for the provided remote, honouring filters and config overrides.
         */
        post: operations["operationsDelete"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/deletefile": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete single file
         * @description Removes a specific object from the remote.
         */
        post: operations["operationsDeletefile"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/fsinfo": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Describe remote capabilities
         * @description Returns backend features, hash support, metadata descriptions, and other info for the remote.
         */
        post: operations["operationsFsinfo"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/hashsum": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Generate hash sums
         * @description Produces a hash sum listing for files under the given path using the requested hash algorithm.
         */
        post: operations["operationsHashsum"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/hashsumfile": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Hash a single file
         * @description Returns the hash of a single file using the specified hash algorithm.
         */
        post: operations["operationsHashsumfile"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/movefile": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Move a single file
         * @description Moves one object from a source remote and path to a destination remote and path.
         */
        post: operations["operationsMovefile"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/publiclink": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create or remove public link
         * @description Creates a share URL for an object or removes an existing link when `unlink=true`.
         */
        post: operations["operationsPubliclink"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/rmdirs": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Remove empty directories
         * @description Deletes empty subdirectories beneath the specified path, optionally leaving the root.
         */
        post: operations["operationsRmdirs"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/settier": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Change storage tier
         * @description Updates the storage class or tier for every object in the specified remote path.
         */
        post: operations["operationsSettier"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/settierfile": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Change file storage tier
         * @description Updates the storage class or tier for a single object.
         */
        post: operations["operationsSettierfile"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/size": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Count remote size
         * @description Reports total size, file count, and number of objects without size metadata.
         */
        post: operations["operationsSize"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/bwlimit": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get or update bandwidth limits
         * @description Reads the current bandwidth limit or applies a new schedule string, just like `rclone rc core/bwlimit`.
         */
        post: operations["coreBwlimit"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/command": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Run an rclone command
         * @description Executes a standard rclone CLI command remotely and streams or returns its output. Don't combine the `STREAM` return types with `Prefer: respond-async`, because the 202 is sent before the command runs.
         */
        post: operations["coreCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/disks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List locally accessible paths
         * @description Returns a list of locally accessible paths including mount points, user directories, and removable volumes.
         */
        post: operations["coreDisks"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/du": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Report disk usage
         * @description Returns disk usage statistics for the supplied local directory (defaults to the cache dir).
         */
        post: operations["coreDu"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/gc": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Force garbage collection
         * @description Triggers Go's garbage collector to release unused memory.
         */
        post: operations["coreGc"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/group-list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List stats groups
         * @description Lists stats groups currently tracked by rclone.
         */
        post: operations["coreGroupList"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/memstats": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Fetch runtime memory stats
         * @description Returns Go runtime memory statistics similar to `runtime.ReadMemStats`.
         */
        post: operations["coreMemstats"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/obscure": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Obscure a clear string
         * @description Obscures a plain-text secret for inclusion in `rclone.conf`.
         */
        post: operations["coreObscure"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/pid": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Return rclone PID
         * @description Returns the process ID of the running rclone instance.
         */
        post: operations["corePid"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/quit": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Terminate rclone
         * @description Stops the rclone process, optionally supplying an exit code.
         */
        post: operations["coreQuit"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/stats-delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete stats group
         * @description Deletes the counters associated with a specific stats group.
         */
        post: operations["coreStatsDelete"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/stats-reset": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Reset stats counters
         * @description Clears counters, errors, and finished transfers for the provided stats group or all groups.
         */
        post: operations["coreStatsReset"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/transferred": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List completed transfers
         * @description Returns up to 100 recently completed transfers for the requested stats group.
         */
        post: operations["coreTransferred"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/debug/set-block-profile-rate": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set the block profile rate
         * @description Controls the fraction of goroutine blocking events reported in the blocking profile. Use a rate of 1 to include every event, or 0 or less to turn profiling off.
         */
        post: operations["debugSetBlockProfileRate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/debug/set-gc-percent": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set the GC target percentage
         * @description Sets the garbage collection target percentage and returns the previous value. A negative percentage effectively turns garbage collection off, unless the memory limit is reached.
         */
        post: operations["debugSetGcPercent"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/debug/set-mutex-profile-fraction": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set the mutex profile fraction
         * @description Controls the fraction of mutex contention events reported in the mutex profile, and returns the previous rate. Use 0 to turn profiling off, or a negative rate to only read the current value.
         */
        post: operations["debugSetMutexProfileFraction"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/debug/set-soft-memory-limit": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set the soft memory limit
         * @description Sets a soft memory limit for the Go runtime, in bytes, and returns the previous limit.
         */
        post: operations["debugSetSoftMemoryLimit"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/fscache/clear": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Clear the remote cache
         * @description Clears the cache of remotes created from backends. Call this after changing a backend's parameters, so that the next call creates the remote again.
         */
        post: operations["fscacheClear"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/fscache/entries": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Count cached remotes
         * @description Returns the number of entries in the cache of remotes.
         */
        post: operations["fscacheEntries"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/mount/listmounts": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List mount points
         * @description Returns the current mount points, which can be passed to `mount/unmount`.
         */
        post: operations["mountListmounts"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/mount/mount": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create a mount point
         * @description Mounts a remote as a file system with FUSE. If `mountType` isn't set, rclone tries `mount`, then `cmount`, then `mount2`. Mount and VFS options can also be given as top-level keys. Rclone rejects any other key.
         */
        post: operations["mountMount"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/mount/types": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List mount types
         * @description Returns the possible mount types, which can be passed to `mount/mount` as `mountType`.
         */
        post: operations["mountTypes"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/mount/unmount": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Unmount a mount point
         * @description Unmounts the mount at `mountPoint`.
         */
        post: operations["mountUnmount"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/mount/unmountall": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Unmount everything
         * @description Unmounts all active mounts, and returns an error if an unmount fails.
         */
        post: operations["mountUnmountall"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rc/noopauth": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Echo parameters (auth required)
         * @description Same as `rc/noop`, but requires authentication to validate access control.
         */
        post: operations["rcNoopAuth"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rc/error": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Return a test error
         * @description Always returns an error response incorporating the supplied parameters, useful for testing error handling.
         */
        post: operations["rcError"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/rc/list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List RC commands
         * @description Returns metadata about every available RC command, including whether authentication is required.
         */
        post: operations["rcList"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/backend/command": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Run backend command
         * @description Invokes a backend-specific management command against an optional remote.
         */
        post: operations["backendCommand"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/cache/expire": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Expire cache entries
         * @description Drops cached directory entries, and optionally cached file data, for the cache backend.
         */
        post: operations["cacheExpire"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/cache/fetch": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Prefetch cache chunks
         * @description Ensures specified file chunks are cached locally for a cache remote. Rclone also accepts `_config` and `_filter` objects here, but this schema leaves them out, because it can't allow objects for only those two keys.
         */
        post: operations["cacheFetch"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/cache/stats": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Show cache stats
         * @description Returns runtime statistics for the cache backend.
         */
        post: operations["cacheStats"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/create": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create remote configuration
         * @description Creates a new remote in `rclone.conf`, mirroring `rclone config create`.
         */
        post: operations["configCreate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/delete": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Delete remote configuration
         * @description Removes an existing remote from `rclone.conf`.
         */
        post: operations["configDelete"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/dump": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Dump configuration
         * @description Returns the contents of the config file as a JSON object keyed by remote name.
         */
        post: operations["configDump"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/get": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get remote configuration
         * @description Returns the key/value settings for a single remote.
         */
        post: operations["configGet"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/listremotes": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List configured remotes
         * @description Returns the names of all remotes defined in the config file.
         */
        post: operations["configListremotes"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/oauthstatus": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get OAuth server status
         * @description Returns the status of the interactive OAuth authentication server, including the authorization URL when it is running.
         */
        post: operations["configOauthstatus"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/oauthstop": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stop OAuth server
         * @description Stops the interactive OAuth authentication server if one is running. Returns an error if no OAuth flow is in progress.
         */
        post: operations["configOauthstop"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/password": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Update remote secrets
         * @description Sets obscured password fields for a remote configuration.
         */
        post: operations["configPassword"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/paths": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Show config paths
         * @description Returns the paths to the config file, cache directory, and temporary directory.
         */
        post: operations["configPaths"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/providers": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List backend providers
         * @description Returns metadata describing each supported storage provider.
         */
        post: operations["configProviders"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/setpath": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set config path
         * @description Points rclone at a specific `rclone.conf` file.
         */
        post: operations["configSetpath"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/unlock": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Unlock encrypted config
         * @description Unlocks the configuration file using the provided password.
         */
        post: operations["configUnlock"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/update": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Update remote configuration
         * @description Updates an existing remote with new parameter values.
         */
        post: operations["configUpdate"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/version": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Report rclone version
         * @description Returns the running rclone version, build metadata, and Go runtime details.
         */
        post: operations["coreVersion"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/core/stats": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Current stats snapshot
         * @description Returns active transfer statistics including bytes transferred, speed, and error counts.
         */
        post: operations["coreStats"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/job/batch": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Run batch of commands
         * @description Run a batch of rclone rc commands concurrently. An input can set `_async` to run in the background, and its entry in `results` is then a job ID. Inputs have no headers, so they can't use `Prefer`.
         */
        post: operations["jobBatch"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/job/list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List jobs
         * @description Returns identifiers of active and recently completed asynchronous jobs. Since rclone 1.75.2 this call requires authentication, so a server with no credentials set up returns 403 unless it runs with `--rc-no-auth`.
         */
        post: operations["jobList"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/job/status": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get job status
         * @description Returns timing, success state, output, and progress for a specific job. Since rclone 1.75.2 this call requires authentication, so a server with no credentials set up returns 403 unless it runs with `--rc-no-auth`.
         */
        post: operations["jobStatus"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/job/stop": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stop job
         * @description Attempts to cancel a running job by ID.
         */
        post: operations["jobStop"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/job/stopgroup": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stop jobs in group
         * @description Cancels all active jobs associated with the provided stats group.
         */
        post: operations["jobStopgroup"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List objects
         * @description Lists objects and directories for a remote path, returning the same fields as `rclone lsjson`.
         */
        post: operations["operationsList"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/stat": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stat an object
         * @description Returns metadata for a single file or directory, mirroring `rclone lsjson` on one entry.
         */
        post: operations["operationsStat"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/about": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get remote quota
         * @description Returns storage quota and usage details for the remote, equivalent to `rclone about`.
         */
        post: operations["operationsAbout"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/uploadfile": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Upload files via multipart
         * @description Accepts multipart/form-data payloads and writes the uploaded files to the specified remote path. Its parameters go in the query string, because rclone doesn't read them from a multipart body. A JSON body returns 200 and uploads nothing. This route can't run in the background.
         */
        post: operations["operationsUploadfile"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/purge": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Purge directory
         * @description Deletes a directory or container and all of its contents. This can take a long time, so run it in the background with `Prefer: respond-async` to avoid HTTP timeouts.
         */
        post: operations["operationsPurge"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/mkdir": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Create directory
         * @description Creates the target directory or container if it does not exist.
         */
        post: operations["operationsMkdir"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/rmdir": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Remove empty directory
         * @description Deletes an empty directory or container.
         */
        post: operations["operationsRmdir"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/operations/check": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Compare source and destination
         * @description Compares source and destination trees, reporting matches, differences, and missing files.
         */
        post: operations["operationsCheck"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/sync": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Sync source to destination
         * @description Synchronises a source remote to a destination remote, making the destination match the source. This can take a long time, so run it in the background with `Prefer: respond-async` to avoid HTTP timeouts.
         */
        post: operations["syncSync"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/copy": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Copy source to destination
         * @description Copies objects from a source remote to a destination remote without deleting destination files. This can take a long time, so run it in the background with `Prefer: respond-async` to avoid HTTP timeouts.
         */
        post: operations["syncCopy"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/move": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Move source to destination
         * @description Moves objects from a source remote to a destination remote, optionally cleaning up empty directories. This can take a long time, so run it in the background with `Prefer: respond-async` to avoid HTTP timeouts.
         */
        post: operations["syncMove"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/sync/bisync": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Bidirectional sync
         * @description Performs a bidirectional synchronisation between two paths, supporting safety checks and recovery options.
         */
        post: operations["syncBisync"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/options/blocks": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List option blocks
         * @description Returns the names of option blocks that can be queried or updated.
         */
        post: operations["optionsBlocks"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/options/get": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get option values
         * @description Returns the current global option values, optionally filtered by block.
         */
        post: operations["optionsGet"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/options/info": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Describe options
         * @description Returns metadata for options, including help text and defaults, grouped by block.
         */
        post: operations["optionsInfo"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/options/set": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Set option values
         * @description Sets temporary option overrides for the running process by supplying key/value pairs grouped under option block names. Provide one or more query parameters whose names match the blocks you want to modify (for example `main`, `rc`, `http`). Each block parameter carries an object of option overrides.
         */
        post: operations["optionsSet"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/options/local": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Show effective options
         * @description Returns the current effective options for this request, including `_config` and `_filter` overrides.
         */
        post: operations["optionsLocal"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/serve/list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List serve instances
         * @description Returns all running `rclone serve` instances with their IDs and options.
         */
        post: operations["serveList"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/serve/start": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Start serve instance
         * @description Launches a new `rclone serve` endpoint (http, webdav, ftp, etc.) with the provided parameters. It also takes the options of the chosen server type, using the option names from `options/info`. Rclone rejects any other key.
         */
        post: operations["serveStart"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/serve/stop": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stop serve instance
         * @description Stops a running `serve` instance identified by its ID.
         */
        post: operations["serveStop"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/serve/stopall": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Stop all serve instances
         * @description Stops every active `serve` instance.
         */
        post: operations["serveStopall"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/serve/types": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List serve types
         * @description Returns the list of supported `rclone serve` protocols.
         */
        post: operations["serveTypes"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/forget": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Forget cached paths
         * @description Evicts specific files or directories from the VFS directory cache. All values must be strings. Rclone also accepts `_config` and `_filter` objects here, but this schema leaves them out, because it can't allow objects for only those two keys.
         */
        post: operations["vfsForget"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/list": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List VFS instances
         * @description Lists the active VFS instances and their identifiers.
         */
        post: operations["vfsList"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/poll-interval": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Get or set poll interval
         * @description Reads or updates the VFS poll interval duration, optionally waiting for the change to apply.
         */
        post: operations["vfsPollInterval"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/queue": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Inspect upload queue
         * @description Returns the contents of the VFS upload queue.
         */
        post: operations["vfsQueue"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/queue-set-expiry": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Adjust queue expiry
         * @description Sets the expiry time of a queued VFS upload item, optionally relative to its current value.
         */
        post: operations["vfsQueueSetExpiry"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/refresh": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Refresh directory cache
         * @description Refreshes one or more directories in the VFS cache, optionally recursively. All values must be strings. Rclone also accepts `_config` and `_filter` objects here, but this schema leaves them out, because it can't allow objects for only those two keys.
         */
        post: operations["vfsRefresh"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/vfs/stats": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Show VFS stats
         * @description Returns VFS statistics including disk cache usage and metadata cache counters.
         */
        post: operations["vfsStats"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/pluginsctl/addPlugin": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Install plugin
         * @description Downloads and installs a plugin into the WebUI from the provided repository URL.
         */
        post: operations["pluginsctlAddPlugin"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/pluginsctl/getPluginsForType": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Filter plugins by MIME type
         * @description Returns plugins matching the requested MIME type and optional plugin type.
         */
        post: operations["pluginsctlGetPluginsForType"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/pluginsctl/listPlugins": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List installed plugins
         * @description Returns metadata for installed production and test plugins.
         */
        post: operations["pluginsctlListPlugins"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/pluginsctl/listTestPlugins": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * List installed test plugins
         * @description Returns metadata for installed test plugins.
         */
        post: operations["pluginsctlListTestPlugins"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/pluginsctl/removePlugin": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Remove plugin
         * @description Uninstalls a plugin from the WebUI.
         */
        post: operations["pluginsctlRemovePlugin"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/pluginsctl/removeTestPlugin": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Remove test plugin
         * @description Uninstalls a test plugin from the WebUI.
         */
        post: operations["pluginsctlRemoveTestPlugin"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
    "/config/unset": {
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        get?: never;
        put?: never;
        /**
         * Unset keys in a remote
         * @description Removes keys from a remote in the config file.
         */
        post: operations["configUnset"];
        delete?: never;
        options?: never;
        head?: never;
        patch?: never;
        trace?: never;
    };
}
export type webhooks = Record<string, never>;
export interface components {
    schemas: {
        RcError: {
            error: string;
            status: number;
            path: string;
            /** @description Original request parameters echoed for debugging. */
            input: {
                [key: string]: unknown;
            } | null;
        };
        ConfigProvider: {
            Aliases?: string[] | null;
            CommandHelp?: components["schemas"]["ConfigProviderCommandHelp"][] | null;
            Description: string;
            Hide?: boolean;
            MetadataInfo?: components["schemas"]["ConfigProviderMetadataInfo"] | null;
            Name: string;
            Options: components["schemas"]["ConfigProviderOption"][];
            Prefix: string;
            Overview?: components["schemas"]["ConfigProviderOverview"];
        } & {
            [key: string]: unknown;
        };
        ConfigProviderCommandHelp: {
            Long?: string;
            Name?: string;
            Opts?: {
                [key: string]: string;
            } | null;
            Short?: string;
        } & {
            [key: string]: unknown;
        };
        ConfigProviderMetadataInfo: {
            Help?: string;
            System?: {
                [key: string]: components["schemas"]["ConfigProviderMetadataSystemEntry"];
            } | null;
        } & {
            [key: string]: unknown;
        };
        ConfigProviderMetadataSystemEntry: {
            Example?: string;
            Help?: string;
            ReadOnly?: boolean;
            Type?: string;
        } & {
            [key: string]: unknown;
        };
        OptionsInfoOptionExample: {
            Value: string;
            Help: string;
        } & {
            [key: string]: unknown;
        };
        OptionsInfoOption: {
            Name: string;
            FieldName: string;
            Help: string;
            /** @description Default value for this option. */
            Default: string[] | boolean | number | string | {
                Value: boolean;
                Valid: boolean;
            };
            /** @description Current value of this option. */
            Value: string[] | boolean | number | string | {
                Value: boolean;
                Valid: boolean;
            } | null;
            Hide: number;
            Required: boolean;
            IsPassword: boolean;
            NoPrefix: boolean;
            Advanced: boolean;
            Exclusive: boolean;
            Sensitive: boolean;
            DefaultStr: string;
            ValueStr: string;
            Type: string;
            Groups?: string;
            ShortOpt?: string;
            Examples?: components["schemas"]["OptionsInfoOptionExample"][];
        } & {
            [key: string]: unknown;
        };
        ConfigProviderOption: {
            Advanced: boolean;
            Default: components["schemas"]["ConfigProviderOptionAny"];
            DefaultStr: string;
            Exclusive: boolean;
            FieldName: string;
            Help: string;
            Hide: number;
            IsPassword: boolean;
            Name: string;
            NoPrefix: boolean;
            Required: boolean;
            Sensitive: boolean;
            Type: components["schemas"]["ConfigProviderOptionType"];
            Value: components["schemas"]["ConfigProviderOptionAny"];
            ValueStr: string;
            Examples?: components["schemas"]["ConfigProviderOptionExample"][];
            ShortOpt?: string;
            Provider?: string;
        } & {
            [key: string]: unknown;
        };
        ConfigProviderOptionExample: {
            Help: string;
            Value: string;
            Provider?: string;
        } & {
            [key: string]: unknown;
        };
        /** @description Value of the option, in whichever type the option uses. A tristate option is an object. */
        ConfigProviderOptionAny: string | number | boolean | unknown[] | {
            Value: boolean;
            Valid: boolean;
        } | null;
        /** @enum {string} */
        ConfigProviderOptionType: "Bits" | "bool" | "CommaSepList" | "Duration" | "Encoding" | "int" | "mtime|atime|btime|ctime" | "SizeSuffix" | "SpaceSepList" | "string" | "stringArray" | "Time" | "Tristate" | "float64";
        /** @description Progress metrics for an in-flight transfer. */
        CoreStatsTransfer: {
            /** @description Bytes transferred so far for this object. */
            bytes?: number;
            /** @description Estimated seconds remaining, when available. */
            eta?: number | null;
            /** @description Stats group name associated with this transfer. */
            group?: string;
            /** @description Remote path of the object being transferred. */
            name?: string;
            /** @description Completion percentage from 0-100. */
            percentage?: number;
            /** @description Total size in bytes of the object. */
            size?: number;
            /** @description Current transfer speed in bytes per second. */
            speed?: number;
            /** @description Current speed in bytes per second as an exponentially weighted moving average. */
            speedAvg?: number;
            /** @description Source remote or filesystem for this transfer. */
            srcFs?: string;
            /** @description Destination remote or filesystem for this transfer. */
            dstFs?: string;
            /** @description Source path within srcFs. */
            srcRemote?: string;
            /** @description Destination path within dstFs. */
            dstRemote?: string;
        } & {
            [key: string]: unknown;
        };
        /** @description Metadata for an item currently undergoing verification. */
        CoreStatsChecking: {
            /** @description Stats group name associated with this verification. */
            group?: string;
            /** @description Remote path of the object being verified. */
            name?: string;
            /** @description Total size in bytes of the object. */
            size?: number;
        } & {
            [key: string]: unknown;
        };
        /** @description A remote defined inline. Needs `type` or `_name`. Other keys are backend options and must be strings. */
        RemoteDefinition: {
            /** @description Backend type, such as `s3`. */
            type?: string;
            /** @description Name of a configured remote. */
            _name?: string;
            /** @description Root path within the remote. */
            _root?: string;
        } & {
            [key: string]: string;
        };
        RcGlobalOptions: {
            /** @description Config overrides for this call only. */
            _config?: {
                [key: string]: unknown;
            };
            /** @description Filter overrides for this call only. */
            _filter?: {
                [key: string]: unknown;
            };
            /** @description Stats group for this call. */
            _group?: string;
        };
        /** @description Summary of the backend from rclone's docs. Its fields are empty for backends without one. */
        ConfigProviderOverview: {
            Backend?: string;
            Name?: string;
            Tier?: string;
            Maintainers?: string;
            FeaturesScore?: number;
            IntegrationTests?: string;
            DataIntegrity?: string;
            Performance?: string;
            Adoption?: string;
            Docs?: string;
            Security?: string;
            Virtual?: boolean;
            Remote?: string;
            Features?: string[] | null;
            Hashes?: string[] | null;
            Precision?: number;
        };
    };
    responses: {
        /** @description Any error response (HTTP 4xx/5xx) */
        RcError: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "application/json": components["schemas"]["RcError"];
            };
        };
        /** @description Request succeeded returning an empty JSON object. */
        EmptyObjectResponse: {
            headers: {
                "x-rclone-jobid": components["headers"]["RcloneJobId"];
                [name: string]: unknown;
            };
            content: {
                "application/json": Record<string, never>;
            };
        };
        /** @description The call is running in the background, because the request sent `Prefer: respond-async`. Poll `job/status` with the job ID. A job can be queried for up to 1 minute after it finishes. */
        AsyncJobResponse: {
            headers: {
                "x-rclone-jobid": components["headers"]["RcloneJobId"];
                "Preference-Applied": components["headers"]["PreferenceApplied"];
                [name: string]: unknown;
            };
            content: {
                "application/json": {
                    /** @description Identifier for this rclone process. */
                    executeId: string;
                    /** @description Job identifier. Pass to /job/status to track progress. */
                    jobid: number;
                };
            };
        };
        /** @description Echoes any supplied parameters, useful for testing RC connectivity. */
        RcNoopResponse: {
            headers: {
                "x-rclone-jobid": components["headers"]["RcloneJobId"];
                [name: string]: unknown;
            };
            content: {
                "application/json": {
                    [key: string]: unknown;
                };
            };
        };
        /** @description An empty object, unless `opt.nonInteractive` is set. Then it describes the next step of the configuration. */
        ConfigStepResponse: {
            headers: {
                "x-rclone-jobid": components["headers"]["RcloneJobId"];
                [name: string]: unknown;
            };
            content: {
                "application/json": {
                    /** @description State to send back to continue. */
                    State?: string;
                    /** @description The next question, if there is one. */
                    Option?: components["schemas"]["ConfigProviderOption"] | null;
                    /** @description Error to show to the user. */
                    Error?: string;
                    /** @description Result to send back to continue. */
                    Result?: string;
                };
            };
        };
        /** @description Missing or wrong credentials. The auth layer sends this as plain text, before rclone's JSON errors apply. */
        UnauthorizedResponse: {
            headers: {
                [name: string]: unknown;
            };
            content: {
                "text/plain": string;
            };
        };
    };
    parameters: {
        /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
        PreferAsyncHeader: "respond-async";
        /** @description Assign the request to a custom stats group. */
        GlobalGroupParam: string;
        /** @description Remote name or path where the uploaded file should be stored. */
        Operations_UploadfilePostFsParam: string;
        /** @description Directory within `fs` to upload into. Use an empty string for the top of `fs`. Each file takes its name from its form part, and rclone skips parts with no file name. */
        Operations_UploadfilePostRemoteParam: string;
        /** @description JSON encoded config overrides for this call only. */
        UploadfileConfigParam: string;
        /** @description JSON encoded filter overrides for this call only. */
        UploadfileFilterParam: string;
    };
    requestBodies: never;
    headers: {
        /** @description ID of the job that ran this call. Streamed responses may not include it. */
        RcloneJobId: string;
        /** @description Confirms that the `Prefer` header was applied. */
        PreferenceApplied: "respond-async";
    };
    pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
    rcNoop: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            200: components["responses"]["RcNoopResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsCleanup: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to clean up, for example `drive:`. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsCopyfile: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Source remote name or path, such as `drive:` or `/` for the local filesystem. */
                    srcFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path to the source object within `srcFs`, for example `dir/file.txt`. */
                    srcRemote: string;
                    /** @description Destination remote name or path, such as `drive2:` or `/` for local filesystem. */
                    dstFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Target path within `dstFs` where the file should be written. */
                    dstRemote: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsCopyurl: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path that will receive the downloaded file, e.g. `drive:`. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Destination path within `fs` where the fetched object will be stored. */
                    remote: string;
                    /** @description Source URL to fetch the object from. */
                    url: string;
                    /** @description Set to true to derive the destination filename from the URL. */
                    autoFilename?: boolean;
                    noClobber?: boolean;
                    headerFilename?: boolean;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsDelete: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path whose contents should be removed. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsDeletefile: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path that contains the file to delete. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Exact path to the file within `fs` that should be deleted. */
                    remote: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsFsinfo: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to inspect, e.g. `drive:`. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                };
            };
        };
        responses: {
            /** @description Capabilities, supported hashes, and metadata for the specified remote. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        Features: {
                            [key: string]: boolean;
                        };
                        Hashes: string[];
                        MetadataInfo?: components["schemas"]["ConfigProviderMetadataInfo"] | null;
                        Name: string;
                        Precision: number;
                        Root: string;
                        String: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsHashsum: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to hash, such as `drive:` or `/`. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Hash algorithm to use, e.g. `md5`, `sha1`, or another supported name. */
                    hashType: string;
                    /** @description Set to true to force reading the data instead of using remote checksums. */
                    download?: boolean;
                    /** @description Set to true to emit hash values in base64 rather than hexadecimal. */
                    base64?: boolean;
                };
            };
        };
        responses: {
            /** @description Hash algorithm used and the ordered hash lines emitted by `operations/hashsum`. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        hashType: string;
                        hashsum: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsHashsumfile: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path containing the file to hash. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path to the specific file within `fs` to hash. */
                    remote: string;
                    /** @description Hash algorithm to use, e.g. `md5`, `sha1`, or another supported name. */
                    hashType: string;
                    /** @description Set to true to force reading the data instead of using remote checksums. */
                    download?: boolean;
                    /** @description Set to true to emit the hash value in base64 rather than hexadecimal. */
                    base64?: boolean;
                };
            };
        };
        responses: {
            /** @description Hash algorithm used and the hash value for a single file from `operations/hashsumfile`. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The hash algorithm that was used. */
                        hashType: string;
                        /** @description The hash value of the file. */
                        hash: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsMovefile: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Source remote name or path containing the file to move. */
                    srcFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path to the source object within `srcFs`. */
                    srcRemote: string;
                    /** @description Destination remote name or path where the file will be moved. */
                    dstFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Destination path within `dstFs` for the moved object. */
                    dstRemote: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsPubliclink: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path hosting the object for which to manage a public link. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path within `fs` to the object for which to create or remove a public link. */
                    remote: string;
                    /** @description Set to true to remove an existing public link instead of creating one. */
                    unlink?: boolean;
                    /** @description Optional expiration time for the public link, formatted as supported by the backend. */
                    expire?: string;
                };
            };
        };
        responses: {
            /** @description Public sharing URL returned by `operations/publiclink`. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** Format: uri */
                        url: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsRmdirs: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to scan for empty directories. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path within `fs` whose empty subdirectories should be removed. */
                    remote: string;
                    /** @description Set to true to preserve the top-level directory even if empty. */
                    leaveRoot?: boolean;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsSettier: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path whose storage class tier should be changed. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Storage tier or class. */
                    tier: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsSettierfile: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path that contains the object whose tier should change. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path within `fs` to the object whose storage class tier should be updated. */
                    remote: string;
                    /** @description Storage tier or class. */
                    tier: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsSize: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to measure aggregate size information for. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                };
            };
        };
        responses: {
            /** @description Aggregate object counts and total size from `operations/size`. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes: number;
                        count: number;
                        sizeless: number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreBwlimit: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Bandwidth limit to apply, for example `off`, `5M`, or a schedule string. */
                    rate?: string;
                };
            };
        };
        responses: {
            /** @description Effective bandwidth limits in bytes per second and human readable form. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytesPerSecond: number;
                        bytesPerSecondRx: number;
                        bytesPerSecondTx: number;
                        rate: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreCommand: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the rclone command to execute, for example `ls` or `lsf`. */
                    command?: string;
                    /** @description Arguments passed to the command. */
                    arg?: string[];
                    /** @description Flags passed to the command. */
                    opt?: {
                        [key: string]: string;
                    };
                    /** @enum {string} */
                    returnType?: "COMBINED_OUTPUT" | "STREAM" | "STREAM_ONLY_STDOUT" | "STREAM_ONLY_STDERR";
                };
            };
        };
        responses: {
            /** @description Outcome of a command run with `core/command`. With the default `returnType` this is JSON. The `STREAM` return types write the output to the body as plain text. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        error: boolean;
                        result?: string | null;
                    };
                    "text/plain": string;
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreDisks: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Locally accessible paths including mount points, user directories, and removable volumes. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Accessible local paths such as disk mount points, user home folders, and removable volumes. */
                        disks: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreDu: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Local directory path to report disk usage for. Defaults to the rclone cache directory when omitted. */
                    dir?: string;
                };
            };
        };
        responses: {
            /** @description Disk usage summary for the requested directory. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dir: string;
                        info: {
                            Free: number;
                            Available: number;
                            Total: number;
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreGc: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreGroupList: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Names of stats groups. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Names of the stats groups, or null when there are none. */
                        groups: string[] | null;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreMemstats: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Memory statistics fields from the Go runtime. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        Alloc: number;
                        BuckHashSys: number;
                        Frees: number;
                        GCSys: number;
                        HeapAlloc: number;
                        HeapIdle: number;
                        HeapInuse: number;
                        HeapObjects: number;
                        HeapReleased: number;
                        HeapSys: number;
                        MCacheInuse: number;
                        MCacheSys: number;
                        MSpanInuse: number;
                        MSpanSys: number;
                        Mallocs: number;
                        OtherSys: number;
                        StackInuse: number;
                        StackSys: number;
                        Sys: number;
                        TotalAlloc: number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreObscure: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Plain-text string to obscure for storage in the config file. */
                    clear: string;
                };
            };
        };
        responses: {
            /** @description Obscured string result. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        obscured: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    corePid: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Process ID payload. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        pid: number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreQuit: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional exit code to use when terminating the rclone process. */
                    exitCode?: number;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreStatsDelete: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Stats group identifier to remove. */
                    group?: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreStatsReset: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Stats group identifier whose counters should be reset. Leave unset to reset all groups. */
                    group?: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreTransferred: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Stats group identifier to filter the completed transfer list. Leave unset for all groups. */
                    group?: string;
                };
            };
        };
        responses: {
            /** @description Completed transfer records including size, status, and timestamps. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        transferred: ({
                            /** @description Stats group identifier this transfer belonged to. */
                            group: string;
                            /** @description Source remote or filesystem used for the transfer. */
                            srcFs?: string;
                            /** @description Destination remote or filesystem used for the transfer. */
                            dstFs?: string;
                            /** @description Source path within `srcFs`, when provided. */
                            srcRemote?: string;
                            /** @description Destination path within `dstFs`, when provided. */
                            dstRemote?: string;
                            name: string;
                            size: number;
                            bytes: number;
                            checked: boolean;
                            /** @description What the transfer was doing, such as `transferring` or `checking`. Bisync adds values such as `listing file - Path1`, so this is free text. */
                            what: string;
                            /** @description ISO8601 timestamp when the transfer started. */
                            started_at: string;
                            /** @description ISO8601 timestamp when the transfer completed. */
                            completed_at: string;
                            timestamp?: number;
                            error: string;
                            jobid?: number;
                        } & {
                            [key: string]: unknown;
                        })[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    debugSetBlockProfileRate: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Sampling interval in nanoseconds for blocking profile collection; use 1 to capture all events. */
                    rate: number;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    debugSetGcPercent: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Target percentage of newly allocated data to trigger garbage collection. */
                    "gc-percent": number;
                };
            };
        };
        responses: {
            /** @description Previous garbage collection target percentage returned after update. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        "existing-gc-percent": number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    debugSetMutexProfileFraction: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Sampling fraction for mutex contention profiling; set to 0 to disable. */
                    rate: number;
                };
            };
        };
        responses: {
            /** @description Previous mutex profiling sampling rate. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        previousRate: number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    debugSetSoftMemoryLimit: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Memory limit in bytes. Use a string for values above 2^53, such as the default of 9223372036854775807. */
                    "mem-limit": number | string;
                };
            };
        };
        responses: {
            /** @description Previous soft memory limit before the change. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        "existing-mem-limit": number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    fscacheClear: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    fscacheEntries: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Number of entries currently cached by the file system cache. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        entries: number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    mountListmounts: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Active mount points with source remote and mount time. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        mountPoints: {
                            Fs: string;
                            MountPoint: string;
                            /** Format: date-time */
                            MountedOn: string;
                        }[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    mountMount: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & ({
                    /** @description Remote path to mount, such as `drive:` or `remote:subdir`. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Absolute local path where the remote should be mounted. */
                    mountPoint: string;
                    /** @description Optional mount implementation to use (`mount`, `cmount`, or `mount2`). */
                    mountType?: string;
                    /** @description Mount options, using the option names from `options/info`. */
                    mountOpt?: {
                        [key: string]: unknown;
                    };
                    /** @description VFS options, using the option names from `options/info`. */
                    vfsOpt?: {
                        [key: string]: unknown;
                    };
                } & {
                    [key: string]: unknown;
                });
            };
        };
        responses: {
            /** @description Mount created successfully. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Actual local path where the remote was mounted. May differ from the requested path (e.g. when '*' is used on Windows). */
                        mountPoint: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    mountTypes: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description List of mount backends available on this platform. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        mountTypes: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    mountUnmount: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Local mount point path to unmount. */
                    mountPoint: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    mountUnmountall: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    rcNoopAuth: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            200: components["responses"]["RcNoopResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    rcError: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    rcList: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Metadata for every available RC command, including auth requirements. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        commands: ({
                            Path?: string;
                            Title?: string;
                            Help?: string;
                            NeedsRequest?: boolean;
                            NeedsResponse?: boolean;
                            /** @description True if the call works without authentication. */
                            NoAuth?: boolean;
                        } & {
                            [key: string]: unknown;
                        })[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    backendCommand: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Backend-specific command to invoke. */
                    command: string;
                    /** @description Remote name or path the backend command should target. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Arguments passed to the backend command. */
                    arg?: string[];
                    /** @description Options passed to the backend command. */
                    opt?: {
                        [key: string]: string;
                    };
                };
            };
        };
        responses: {
            /** @description Backend command output and any additional returned fields. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Backend command result payload */
                        result?: unknown;
                    } & {
                        [key: string]: unknown;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    cacheExpire: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote path to expire from the cache, e.g. `remote:path/to/dir`. */
                    remote: string;
                    /** @description Set this to drop cached chunk data along with directory entries. Rclone only checks whether the key is present, so any value turns it on, including `false`. */
                    withData?: boolean;
                };
            };
        };
        responses: {
            /** @description Confirmation that the path was cleared. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always `ok`. */
                        status: string;
                        /** @description Describes what was cleared. */
                        message: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    cacheFetch: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": {
                    /** @description Stats group for this call. */
                    _group?: string;
                    /** @description Comma-separated chunk specifier list (e.g. `0:10,25:30`) describing file pieces to prefetch. */
                    chunks: string;
                    /** @description File to fetch chunks of. Add more with keys that start with `file`, such as `file2`. */
                    file?: string;
                } & {
                    [key: string]: string;
                };
            };
        };
        responses: {
            /** @description What was fetched for each file. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Results keyed by file name. */
                        status: {
                            [key: string]: {
                                /** @description Error message, or an empty string. */
                                Error: string;
                                /** @description Number of chunks fetched. */
                                FetchedChunks: number;
                            };
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    cacheStats: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Statistics for the cache remote. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Always `ok`. */
                        status: string;
                        /** @description Cache statistics. */
                        stats: {
                            [key: string]: unknown;
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configCreate: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the new remote configuration. */
                    name: string;
                    /** @description Backend options for the remote. */
                    parameters: {
                        [key: string]: unknown;
                    };
                    /** @description Backend type identifier, such as `drive`, `s3`, or `dropbox`. */
                    type: string;
                    /** @description Options that control the configuration. */
                    opt?: {
                        obscure?: boolean;
                        noObscure?: boolean;
                        noOutput?: boolean;
                        nonInteractive?: boolean;
                        continue?: boolean;
                        all?: boolean;
                        state?: string;
                        result?: string;
                    };
                };
            };
        };
        responses: {
            200: components["responses"]["ConfigStepResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configDelete: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the remote configuration to delete. */
                    name: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configDump: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Entire rclone configuration grouped by remote. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        [key: string]: {
                            [key: string]: string;
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configGet: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the remote configuration to fetch. */
                    name: string;
                };
            };
        };
        responses: {
            /** @description Configuration key/value pairs for the requested remote. An empty object if there's no remote with that name. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        type?: string;
                    } & {
                        [key: string]: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configListremotes: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Names of configured remotes. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        remotes: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configOauthstatus: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Status of the interactive OAuth authentication server. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /**
                         * @description Whether the OAuth authentication server is currently running.
                         * @enum {string}
                         */
                        status: "running" | "stopped";
                        /** @description Authorization URL to open in a browser. Present only when status is "running". */
                        authUrl?: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configOauthstop: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configPassword: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the remote whose secrets should be updated. */
                    name: string;
                    /** @description Password options for the remote. */
                    parameters: {
                        [key: string]: unknown;
                    };
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configPaths: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Paths to the config file, cache directory, and temporary directory. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        cache: string;
                        config: string;
                        temp: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configProviders: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Available backend providers and their metadata. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        providers: components["schemas"]["ConfigProvider"][];
                    } & {
                        [key: string]: unknown;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configSetpath: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Absolute path to the `rclone.conf` file that rclone should use. */
                    path: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configUnlock: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Password used to unlock an encrypted config file. */
                    configPassword: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configUpdate: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the remote configuration to update. */
                    name: string;
                    /** @description Backend options for the remote. */
                    parameters: {
                        [key: string]: unknown;
                    };
                    /** @description Options that control the configuration. */
                    opt?: {
                        obscure?: boolean;
                        noObscure?: boolean;
                        noOutput?: boolean;
                        nonInteractive?: boolean;
                        continue?: boolean;
                        all?: boolean;
                        state?: string;
                        result?: string;
                    };
                };
            };
        };
        responses: {
            200: components["responses"]["ConfigStepResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreVersion: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description rclone version, build information, and runtime details. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Full semantic version string (e.g. 1.67.0). */
                        version: string;
                        /** @description Operating system rclone is running on (e.g. linux, darwin). */
                        os: string;
                        /** @description CPU architecture (e.g. amd64, arm64). */
                        arch: string;
                        /** @description Version number broken into components. */
                        decomposed: number[];
                        /** @description True when built directly from a git checkout. */
                        isGit: boolean;
                        /** @description Indicates whether this build is a beta version. */
                        isBeta: boolean;
                        /** @description Go toolchain version used to build rclone. */
                        goVersion: string;
                        /** @description OS Version (e.g. ubuntu 24.04 (64 bit)). */
                        osVersion?: string;
                        /** @description OS Kernel version (e.g. 6.8.0-86-generic (x86_64)). */
                        osKernel?: string;
                        /** @description CPU architecture in use (e.g. arm64 (ARMv8 compatible)). */
                        osArch?: string;
                        /** @description Linking mode for the binary (static or dynamic). */
                        linking: string;
                        /** @description Space separated Go build tags, if any. */
                        goTags: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    coreStats: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Stats group identifier to return a snapshot for. Leave unset to include all groups. */
                    group?: string;
                    /** @description When true, omit the `transferring` and `checking` arrays from the response. */
                    short?: boolean;
                };
            };
        };
        responses: {
            /** @description Current transfer statistics including totals, rates, and recent activity. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        bytes: number;
                        checks: number;
                        deletedDirs: number;
                        deletes: number;
                        elapsedTime: number;
                        errors: number;
                        eta?: number | null;
                        fatalError: boolean;
                        lastError?: string;
                        retryError: boolean;
                        renames: number;
                        listed?: number;
                        serverSideCopies: number;
                        serverSideCopyBytes: number;
                        serverSideMoveBytes: number;
                        serverSideMoves: number;
                        speed: number;
                        totalBytes: number;
                        totalChecks: number;
                        totalTransfers: number;
                        transferTime: number;
                        transfers: number;
                        /** @description Active transfers currently in progress grouped by stats group. */
                        transferring?: components["schemas"]["CoreStatsTransfer"][];
                        /** @description Objects currently undergoing verification operations. */
                        checking?: components["schemas"]["CoreStatsChecking"][];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    jobBatch: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Do this many commands concurrently. Defaults to --transfers if not set. */
                    concurrency?: number;
                    /** @description List of inputs to the commands with an extra _path parameter. */
                    inputs: ({
                        /** @description rc/path */
                        _path: string;
                        /** @description Stats group this input accumulates under. */
                        _group?: string;
                        /** @description Run this item in the background. Its entry in `results` is then a job ID. Items have no headers, so `Prefer` is not an option here. */
                        _async?: boolean;
                    } & {
                        [key: string]: unknown;
                    })[];
                };
            };
        };
        responses: {
            /** @description Results of the batch job execution. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description One entry for each input, in order. Each is that command's result, its error, or a job ID if the input set `_async`. */
                        results: {
                            [key: string]: unknown;
                        }[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    jobList: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Identifiers of active and recently completed async jobs. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Identifier for this rclone process. */
                        executeId: string;
                        /** @description Job IDs suitable for use with `job/status` and `job/stop`. */
                        jobids: number[];
                        /** @description Array of integer job ids that are running. */
                        runningIds: number[];
                        /** @description Array of integer job ids that are finished. */
                        finishedIds: number[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    jobStatus: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Job id. */
                    jobid: number;
                };
            };
        };
        responses: {
            /** @description Detailed status for a background job, including timing, success flag, and optional output. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Identifier for this rclone process. */
                        executeId: string;
                        /** @description True once the job has completed. */
                        finished: boolean;
                        /** @description Execution time in seconds. */
                        duration: number;
                        /** @description Timestamp when the job finished. (e.g. '2025-12-26T18:50:20.528746884+01:00') */
                        endTime: string;
                        /** @description Error message, or empty string on success. */
                        error: string;
                        /** @description Job identifier. */
                        id: number;
                        /** @description Timestamp when the job started. (e.g. '2025-12-24T18:50:20.5281314+01:00') */
                        startTime: string;
                        /** @description True if the job completed successfully. */
                        success: boolean;
                        /** @description Synchronous-style output payload when available. */
                        output?: unknown;
                        /** @description Progress measurements supplied by the underlying command. */
                        progress?: unknown;
                        /** @description Stats group of the job. */
                        group: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    jobStop: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Job id. */
                    jobid: number;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    jobStopgroup: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Stats group name whose active jobs should be stopped. */
                    group: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsList: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to list, for example `drive:`. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Directory path within `fs` to list; leave empty to target the root. */
                    remote: string;
                    /** @description Options that control the listing. */
                    opt?: {
                        recurse?: boolean;
                        noModTime?: boolean;
                        noMimeType?: boolean;
                        showEncrypted?: boolean;
                        showOrigIDs?: boolean;
                        showHash?: boolean;
                        dirsOnly?: boolean;
                        filesOnly?: boolean;
                        metadata?: boolean;
                        hashTypes?: string[];
                    };
                };
            };
        };
        responses: {
            /** @description Directory listing entries from `operations/list`, mirroring the `lsjson` format. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Array of entries equivalent to the items returned by `rclone lsjson`. */
                        list: {
                            /** @description Path relative to the requested remote root. */
                            Path: string;
                            /** @description Base name of the entry. */
                            Name: string;
                            /** @description Object size in bytes. */
                            Size?: number;
                            /** @description MIME type where available. */
                            MimeType?: string;
                            /** @description Modification timestamp in RFC3339 format. */
                            ModTime?: string;
                            /** @description True if the entry represents a directory. */
                            IsDir: boolean;
                            /** @description Hash digests keyed by algorithm when requested. */
                            Hashes?: {
                                [key: string]: string;
                            };
                            /** @description Backend-specific identifier when provided. */
                            ID?: string;
                            /** @description Original backend identifier when recorded. */
                            OrigID?: string;
                            /** @description True for bucket/root entries on bucket-based remotes. */
                            IsBucket?: boolean;
                            /** @description Storage class or tier, if supplied by the backend. */
                            Tier?: string;
                            /** @description Encrypted entry name when using crypt remotes. */
                            Encrypted?: string;
                            /** @description Encrypted path when using crypt remotes. */
                            EncryptedPath?: string;
                            /** @description Backend-provided metadata map. */
                            Metadata?: {
                                [key: string]: unknown;
                            };
                        }[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsStat: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path that contains the item to inspect. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path to the file or directory within `fs` to describe. */
                    remote: string;
                    /** @description Options that control the listing. */
                    opt?: {
                        recurse?: boolean;
                        noModTime?: boolean;
                        noMimeType?: boolean;
                        showEncrypted?: boolean;
                        showOrigIDs?: boolean;
                        showHash?: boolean;
                        dirsOnly?: boolean;
                        filesOnly?: boolean;
                        metadata?: boolean;
                        hashTypes?: string[];
                    };
                };
            };
        };
        responses: {
            /** @description Metadata for a single file or directory from `operations/stat`. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        item: {
                            /** @description Path relative to the remote root. */
                            Path: string;
                            /** @description Base name of the entry. */
                            Name: string;
                            /** @description Object size in bytes. */
                            Size: number;
                            /** @description MIME type where available. */
                            MimeType: string;
                            /** @description Modification timestamp in RFC3339 format. */
                            ModTime: string;
                            /** @description True if the entry is a directory. */
                            IsDir: boolean;
                            /** @description Hash digests keyed by algorithm when requested. */
                            Hashes?: {
                                [key: string]: string;
                            };
                            /** @description Backend-specific identifier when provided. */
                            ID?: string;
                            /** @description Original backend identifier when recorded. */
                            OrigID?: string;
                            /** @description True for bucket/root entries on bucket-based remotes. */
                            IsBucket?: boolean;
                            /** @description Storage class or tier, if supplied by the backend. */
                            Tier?: string;
                            /** @description Encrypted entry name when using crypt remotes. */
                            Encrypted?: string;
                            /** @description Encrypted path when using crypt remotes. */
                            EncryptedPath?: string;
                            /** @description Backend-provided metadata map. */
                            Metadata?: {
                                [key: string]: unknown;
                            };
                        } | null;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsAbout: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path to query for capacity information. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                };
            };
        };
        responses: {
            /** @description Quota and usage information from `operations/about`, including total, used, and free space. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        total?: number;
                        used?: number;
                        free?: number;
                        trashed?: number;
                        other?: number;
                        objects?: number;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsUploadfile: {
        parameters: {
            query: {
                /** @description Remote name or path where the uploaded file should be stored. */
                fs: components["parameters"]["Operations_UploadfilePostFsParam"];
                /** @description Directory within `fs` to upload into. Use an empty string for the top of `fs`. Each file takes its name from its form part, and rclone skips parts with no file name. */
                remote: components["parameters"]["Operations_UploadfilePostRemoteParam"];
                /** @description Assign the request to a custom stats group. */
                _group?: components["parameters"]["GlobalGroupParam"];
                /** @description JSON encoded config overrides for this call only. */
                _config?: components["parameters"]["UploadfileConfigParam"];
                /** @description JSON encoded filter overrides for this call only. */
                _filter?: components["parameters"]["UploadfileFilterParam"];
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        /** @description Multipart form payload containing one or more files to upload. */
        requestBody?: {
            content: {
                "multipart/form-data": unknown;
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsPurge: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path from which to remove all contents. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path within `fs` whose contents should be purged. */
                    remote: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsMkdir: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path in which to create a directory. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Directory path within `fs` to create. */
                    remote: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsRmdir: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Remote name or path containing the directory to remove. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Directory path within `fs` to delete. */
                    remote: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    operationsCheck: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Source remote name or path to verify, e.g. `drive:`. Required unless `checkFileHash` is set. */
                    srcFs?: string | components["schemas"]["RemoteDefinition"];
                    /** @description Destination remote name or path that should match the source. */
                    dstFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Set to true to read file contents during comparison instead of relying on hashes. */
                    download?: boolean;
                    /** @description Hash name to expect in the supplied SUM file, such as `md5`. */
                    checkFileHash?: string;
                    /** @description Remote containing the checksum SUM file when using `checkFileHash`. */
                    checkFileFs?: string | components["schemas"]["RemoteDefinition"];
                    /** @description Path within `checkFileFs` to the checksum SUM file. */
                    checkFileRemote?: string;
                    /** @description Set to true to only ensure that source files exist on the destination. */
                    oneWay?: boolean;
                    /** @description Set to true to include a combined summary report in the response. */
                    combined?: boolean;
                    /** @description Set to true to report files missing from the source. */
                    missingOnSrc?: boolean;
                    /** @description Set to true to report files missing from the destination. */
                    missingOnDst?: boolean;
                    /** @description Set to true to include matching files in the report. */
                    match?: boolean;
                    /** @description Set to true to include differing files in the report. */
                    differ?: boolean;
                    /** @description Set to true to include entries that encountered errors. */
                    error?: boolean;
                };
            };
        };
        responses: {
            /** @description Comparison summary from `operations/check`, including missing, matching, and differing files. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description True when the check completes without differences or errors. */
                        success: boolean;
                        /** @description Human readable status string. */
                        status: string;
                        /** @description Hash algorithm used for comparisons when applicable. */
                        hashType?: string;
                        /** @description Combined summary lines when `combined=true` is requested. */
                        combined?: string[];
                        /** @description Files present on the destination but missing from the source. */
                        missingOnSrc?: string[];
                        /** @description Files present on the source but missing from the destination. */
                        missingOnDst?: string[];
                        /** @description Files that matched on both sides. */
                        match?: string[];
                        /** @description Files that differed between source and destination. */
                        differ?: string[];
                        /** @description Entries that produced errors during the check. */
                        error?: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    syncSync: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Source remote path to sync from, e.g. `drive:src`. */
                    srcFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Destination remote path to sync to, e.g. `drive:dst`. */
                    dstFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Set to true to create empty source directories on the destination. */
                    createEmptySrcDirs?: boolean;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    syncCopy: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Source remote path to copy from. */
                    srcFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Destination remote path to copy to. */
                    dstFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Set to true to replicate empty source directories on the destination. */
                    createEmptySrcDirs?: boolean;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    syncMove: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Source remote path whose contents will be moved. */
                    srcFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Destination remote path that will receive moved files. */
                    dstFs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Set to true to create empty source directories on the destination. */
                    createEmptySrcDirs?: boolean;
                    /** @description Set to true to delete empty directories from the source after the move completes. */
                    deleteEmptySrcDirs?: boolean;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    syncBisync: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description First remote directory, e.g. `drive:path1`. */
                    path1: string | components["schemas"]["RemoteDefinition"];
                    /** @description Second remote directory, e.g. `drive:path2`. */
                    path2: string | components["schemas"]["RemoteDefinition"];
                    /** @description Set to true to simulate the bisync run without making changes. */
                    dryRun?: boolean;
                    /** @description Set to true to perform a one-time resync, rebuilding bisync history. */
                    resync?: boolean;
                    /** @description Set to true to abort if `RCLONE_TEST` files are missing on either side. */
                    checkAccess?: boolean;
                    /** @description Override the access-check sentinel filename; defaults to `RCLONE_TEST`. */
                    checkFilename?: string;
                    maxDelete?: number;
                    /** @description Set to true to bypass the `maxDelete` safety check. */
                    force?: boolean;
                    /** @enum {string} */
                    checkSync?: "true" | "false" | "only";
                    /** @description Set to true to mirror empty directories between the two paths. */
                    createEmptySrcDirs?: boolean;
                    /** @description Set to true to remove empty directories during cleanup. */
                    removeEmptyDirs?: boolean;
                    /** @description Path to an rclone filters file applied to both paths. */
                    filtersFile?: string;
                    /** @description Set to true to ignore checksum differences when comparing listings. */
                    ignoreListingChecksum?: boolean;
                    /** @description Set to true to allow retrying after certain recoverable errors. */
                    resilient?: boolean;
                    /** @description Directory path used to store bisync working files. */
                    workdir?: string;
                    /** @description Set to true to keep bisync working files after completion. */
                    noCleanup?: boolean;
                    backupDir1?: string;
                    backupDir2?: string;
                    compare?: string;
                    conflictLoser?: string;
                    conflictResolve?: string;
                    conflictSuffix?: string;
                    downloadHash?: boolean;
                    maxLock?: string;
                    noSlowHash?: boolean;
                    recover?: boolean;
                    resyncMode?: string;
                    slowHashSyncOnly?: boolean;
                };
            };
        };
        responses: {
            /** @description Bisync completed with session details. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Captured output from the bisync operation. */
                        output: string;
                        /** @description Session name derived from the two filesystems. */
                        session: string;
                        /** @description Absolute path to the bisync working directory. */
                        workDir: string;
                        /** @description Base path for listing files. */
                        basePath: string;
                        /** @description Path to the Path1 listing file. */
                        listing1: string;
                        /** @description Path to the Path2 listing file. */
                        listing2: string;
                        /** @description Path to the log file. */
                        logFile: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    optionsBlocks: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Names of option blocks that can be queried with `options/get` or `options/info`. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        options: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    optionsGet: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional comma-separated list of option block names to return. */
                    blocks?: string;
                };
            };
        };
        responses: {
            /** @description Current global option values keyed by block name. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dlna?: {
                            [key: string]: unknown;
                        };
                        filter?: {
                            [key: string]: unknown;
                        };
                        ftp?: {
                            [key: string]: unknown;
                        };
                        http?: {
                            [key: string]: unknown;
                        };
                        log?: {
                            [key: string]: unknown;
                        };
                        main?: {
                            [key: string]: unknown;
                        };
                        mount?: {
                            [key: string]: unknown;
                        };
                        nfs?: {
                            [key: string]: unknown;
                        };
                        proxy?: {
                            [key: string]: unknown;
                        };
                        rc?: {
                            [key: string]: unknown;
                        };
                        restic?: {
                            [key: string]: unknown;
                        };
                        s3?: {
                            [key: string]: unknown;
                        };
                        sftp?: {
                            [key: string]: unknown;
                        };
                        vfs?: {
                            [key: string]: unknown;
                        };
                        webdav?: {
                            [key: string]: unknown;
                        };
                    } & {
                        [key: string]: unknown;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    optionsInfo: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional comma-separated list of option block names to describe. */
                    blocks?: string;
                };
            };
        };
        responses: {
            /** @description Metadata describing available options, organised by block. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        dlna?: components["schemas"]["OptionsInfoOption"][];
                        filter?: components["schemas"]["OptionsInfoOption"][];
                        ftp?: components["schemas"]["OptionsInfoOption"][];
                        http?: components["schemas"]["OptionsInfoOption"][];
                        log?: components["schemas"]["OptionsInfoOption"][];
                        main?: components["schemas"]["OptionsInfoOption"][];
                        mount?: components["schemas"]["OptionsInfoOption"][];
                        nfs?: components["schemas"]["OptionsInfoOption"][];
                        proxy?: components["schemas"]["OptionsInfoOption"][];
                        rc?: components["schemas"]["OptionsInfoOption"][];
                        restic?: components["schemas"]["OptionsInfoOption"][];
                        s3?: components["schemas"]["OptionsInfoOption"][];
                        sftp?: components["schemas"]["OptionsInfoOption"][];
                        vfs?: components["schemas"]["OptionsInfoOption"][];
                        webdav?: components["schemas"]["OptionsInfoOption"][];
                    } & {
                        [key: string]: components["schemas"]["OptionsInfoOption"][];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    optionsSet: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description Overrides for the `dlna` option block. */
                    dlna?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `filter` option block. */
                    filter?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `ftp` option block. */
                    ftp?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `main` option block. */
                    main?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `http` option block. */
                    http?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `log` option block. */
                    log?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `mount` option block. */
                    mount?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `nfs` option block. */
                    nfs?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `proxy` option block. */
                    proxy?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `rc` option block. */
                    rc?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `restic` option block. */
                    restic?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `s3` option block. */
                    s3?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `sftp` option block. */
                    sftp?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `vfs` option block. */
                    vfs?: {
                        [key: string]: unknown;
                    };
                    /** @description Overrides for the `webdav` option block. */
                    webdav?: {
                        [key: string]: unknown;
                    };
                    /** @description Stats group for this call. */
                    _group?: string;
                } & {
                    [key: string]: unknown;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    optionsLocal: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Effective option values for the current request, separated into config and filter sections. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        config: {
                            AskPassword: boolean;
                            AutoConfirm: boolean;
                            BackupDir: string;
                            BindAddr: string;
                            BufferSize: number;
                            BwLimit: string;
                            BwLimitFile: string;
                            CaCert: string[];
                            CheckFirst: boolean;
                            CheckSum: boolean;
                            Checkers: number;
                            ClientCert: string;
                            ClientKey: string;
                            CompareDest: string[];
                            ConnectTimeout: number;
                            Cookie: boolean;
                            CopyDest: string[];
                            CutoffMode: string;
                            DataRateUnit: string;
                            DefaultTime: string;
                            DeleteMode: number;
                            DisableFeatures: string | null;
                            DisableHTTP2: boolean;
                            DisableHTTPKeepAlives: boolean;
                            DownloadHeaders: string | null;
                            DryRun: boolean;
                            Dump: string;
                            ErrorOnNoTransfer: boolean;
                            ExpectContinueTimeout: number;
                            FixCase: boolean;
                            FsCacheExpireDuration: number;
                            FsCacheExpireInterval: number;
                            Headers: string | null;
                            HumanReadable: boolean;
                            IgnoreCaseSync: boolean;
                            IgnoreChecksum: boolean;
                            IgnoreErrors: boolean;
                            IgnoreExisting: boolean;
                            IgnoreSize: boolean;
                            IgnoreTimes: boolean;
                            Immutable: boolean;
                            Inplace: boolean;
                            InsecureSkipVerify: boolean;
                            Interactive: boolean;
                            KvLockTime: number;
                            Links: boolean;
                            LogLevel: string;
                            LowLevelRetries: number;
                            MaxBacklog: number;
                            MaxBufferMemory: number;
                            MaxDelete: number;
                            MaxDeleteSize: number;
                            MaxDepth: number;
                            MaxDuration: number;
                            MaxStatsGroups: number;
                            MaxTransfer: number;
                            Metadata: boolean;
                            MetadataMapper: string | null;
                            MetadataSet: string | null;
                            ModifyWindow: number;
                            MultiThreadChunkSize: number;
                            MultiThreadCutoff: number;
                            MultiThreadSet: boolean;
                            MultiThreadStreams: number;
                            MultiThreadWriteBufferSize: number;
                            NoCheckDest: boolean;
                            NoConsole: boolean;
                            NoGzip: boolean;
                            NoTraverse: boolean;
                            NoUnicodeNormalization: boolean;
                            NoUpdateDirModTime: boolean;
                            NoUpdateModTime: boolean;
                            OrderBy: string;
                            PartialSuffix: string;
                            PasswordCommand: string | null;
                            Progress: boolean;
                            ProgressTerminalTitle: boolean;
                            RefreshTimes: boolean;
                            Retries: number;
                            RetriesInterval: number;
                            ServerSideAcrossConfigs: boolean;
                            SizeOnly: boolean;
                            StatsFileNameLength: number;
                            StatsLogLevel: string;
                            StatsOneLine: boolean;
                            StatsOneLineDate: boolean;
                            StatsOneLineDateFormat: string;
                            StreamingUploadCutoff: number;
                            Suffix: string;
                            SuffixKeepExtension: boolean;
                            TPSLimit: number;
                            TPSLimitBurst: number;
                            TerminalColorMode: string;
                            Timeout: number;
                            TrackRenames: boolean;
                            TrackRenamesStrategy: string;
                            TrafficClass: number;
                            Transfers: number;
                            UpdateOlder: boolean;
                            UploadHeaders: string | null;
                            UseJSONLog: boolean;
                            UseListR: boolean;
                            UseMmap: boolean;
                            UseServerModTime: boolean;
                            UserAgent: string;
                            ListCutoff: number;
                            ClientPass: string;
                            MaxConnections: number;
                            NameTransform: string[] | null;
                            HTTPProxy: string;
                        };
                        filter: {
                            DeleteExcluded: boolean;
                            ExcludeFile: string[];
                            ExcludeFrom: string[];
                            ExcludeRule: string[];
                            FilesFrom: string[];
                            FilesFromRaw: string[];
                            FilterFrom: string[];
                            FilterRule: string[];
                            HashFilter: string;
                            IgnoreCase: boolean;
                            IncludeFrom: string[];
                            IncludeRule: string[];
                            MaxAge: number;
                            MaxSize: number;
                            MetaRules: {
                                ExcludeFrom: string[];
                                ExcludeRule: string[];
                                FilterFrom: string[];
                                FilterRule: string[];
                                IncludeFrom: string[];
                                IncludeRule: string[];
                            };
                            MinAge: number;
                            MinSize: number;
                            FilesFrom0: string[] | null;
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    serveList: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description List of active `serve` instances, including their IDs, bind addresses, and parameters. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        list: {
                            /** @description Identifier returned by `serve/start`. */
                            id: string;
                            /** @description Address and port the server is listening on. */
                            addr: string;
                            /** @description Serve configuration parameters supplied at startup. */
                            params: {
                                fs: string | components["schemas"]["RemoteDefinition"];
                                type: string;
                                opt?: {
                                    [key: string]: unknown;
                                };
                                vfsOpt?: {
                                    [key: string]: unknown;
                                };
                            } & {
                                [key: string]: unknown;
                            };
                        }[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    serveStart: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & ({
                    /** @description Type of server to start (e.g. `http`, `webdav`, `ftp`, `sftp`). */
                    type: string;
                    /** @description Remote path that will be served. */
                    fs: string | components["schemas"]["RemoteDefinition"];
                    /** @description Address and port to bind the server to, such as `:5572` or `localhost:8080`. */
                    addr?: string;
                } & {
                    [key: string]: unknown;
                });
            };
        };
        responses: {
            /** @description Confirmation of a newly started server, including ID and bound address. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Address and port the server is listening on. */
                        addr: string;
                        /** @description Identifier to pass to `serve/stop`. */
                        id: string;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    serveStop: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Identifier of the running serve instance returned by `serve/start`. */
                    id: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    serveStopall: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    serveTypes: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Supported rclone serve protocols. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        types: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsForget: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description Stats group for this call. */
                    _group?: string;
                    /** @description Optional VFS identifier to target; required when more than one VFS is active. */
                    fs?: string;
                    /** @description File to forget. Add more with keys that start with `file`, such as `file2`. */
                    file?: string;
                    /** @description Directory to forget. Add more with keys that start with `dir`, such as `dir2`. */
                    dir?: string;
                } & {
                    [key: string]: string;
                };
            };
        };
        responses: {
            /** @description Paths evicted from the VFS directory cache. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Paths that were successfully forgotten. */
                        forgotten: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsList: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Identifiers for the VFS instances currently in use. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description VFS name that can be used with other VFS endpoints. */
                        vfses: string[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsPollInterval: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional VFS identifier whose poll interval should be queried or modified. */
                    fs?: string;
                    /** @description Duration string (e.g. `5m`) to set as the new poll interval. */
                    interval?: string;
                    /** @description Duration to wait for the poll interval change to take effect; `0` waits indefinitely. */
                    timeout?: string;
                };
            };
        };
        responses: {
            /** @description Status of the poll-interval setting, possibly including the new interval. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description True if polling is on. */
                        enabled: boolean;
                        /** @description True if the remote supports polling. */
                        supported: boolean;
                        /** @description The polling interval. */
                        interval: {
                            /** @description Interval in nanoseconds. */
                            raw: number;
                            /** @description Interval in whole seconds. */
                            seconds: number;
                            /** @description Interval as text, such as `1m0s`. */
                            string: string;
                        };
                        /** @description True if setting the interval timed out. Only present when setting it. */
                        timeout?: boolean;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsQueue: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional VFS identifier whose upload queue should be inspected. */
                    fs?: string;
                };
            };
        };
        responses: {
            /** @description Upload queue entries for the selected VFS. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Files waiting to upload. Absent when the VFS has no cache. */
                        queue?: {
                            /** @description Full path of the file. */
                            name: string;
                            /** @description Queue item ID, for `vfs/queue-set-expiry`. */
                            id: number;
                            /** @description Size in bytes. */
                            size: number;
                            /** @description Seconds until the file is eligible for transfer. */
                            expiry: number;
                            /** @description Upload attempts so far. */
                            tries: number;
                            /** @description Delay between upload attempts in seconds. */
                            delay: number;
                            /** @description True if the file is uploading now. */
                            uploading: boolean;
                        }[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsQueueSetExpiry: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional VFS identifier for the queued item. */
                    fs?: string;
                    /** @description Queue item ID as returned by `vfs/queue`. */
                    id: number;
                    /** @description New eligibility time in seconds (may be negative for immediate upload). */
                    expiry: number;
                    /** @description Set to true to treat `expiry` as relative to the current value. */
                    relative?: boolean;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsRefresh: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": {
                    /** @description Stats group for this call. */
                    _group?: string;
                    /** @description Optional VFS identifier whose directory cache should be refreshed. */
                    fs?: string;
                    /**
                     * @description Must be the string `true` or `false`, not a JSON boolean.
                     * @enum {string}
                     */
                    recursive?: "true" | "false";
                    /** @description Directory to refresh. Add more with keys that start with `dir`, such as `dir2`. */
                    dir?: string;
                } & {
                    [key: string]: string;
                };
            };
        };
        responses: {
            /** @description Acknowledgement of directories refreshed in the VFS cache. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Map of refreshed directories to status messages. */
                        result: {
                            [key: string]: string;
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    vfsStats: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Optional VFS identifier whose statistics should be returned. */
                    fs?: string;
                };
            };
        };
        responses: {
            /** @description Runtime statistics for a VFS, including disk cache and metadata cache state. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Name of the VFS. */
                        fs: string;
                        /** @description Number of active references to the VFS. */
                        inUse: number;
                        /** @description Disk cache metrics when caching is enabled. */
                        diskCache?: {
                            /** @description Bytes used by the cache. */
                            bytesUsed?: number;
                            /** @description Files with errors. */
                            erroredFiles?: number;
                            /** @description Files in the cache. */
                            files?: number;
                            /** @description Internal number of the hash the cache uses. */
                            hashType?: number;
                            /** @description True if the cache has run out of space. */
                            outOfSpace?: boolean;
                            /** @description Directory of the cached data. */
                            path?: string;
                            /** @description Directory of the cached metadata. */
                            pathMeta?: string;
                            /** @description Uploads running now. */
                            uploadsInProgress?: number;
                            /** @description Uploads waiting to run. */
                            uploadsQueued?: number;
                        } | null;
                        /** @description In-memory metadata cache counters. */
                        metadataCache: {
                            /** @description Directories cached. */
                            dirs?: number;
                            /** @description Files cached. */
                            files?: number;
                        };
                        /** @description Effective options of the VFS. Durations are in nanoseconds, and sizes are in bytes. */
                        opt: {
                            NoSeek?: boolean;
                            NoChecksum?: boolean;
                            ReadOnly?: boolean;
                            Links?: boolean;
                            NoModTime?: boolean;
                            DirCacheTime?: number;
                            Refresh?: boolean;
                            PollInterval?: number;
                            Umask?: number;
                            UID?: number;
                            GID?: number;
                            DirPerms?: number;
                            FilePerms?: number;
                            LinkPerms?: number;
                            ChunkSize?: number;
                            ChunkSizeLimit?: number;
                            ChunkStreams?: number;
                            CacheMode?: number;
                            CacheMaxAge?: number;
                            CacheMaxSize?: number;
                            CacheMinFreeSpace?: number;
                            CachePollInterval?: number;
                            CaseInsensitive?: boolean;
                            BlockNormDupes?: boolean;
                            WriteWait?: number;
                            ReadWait?: number;
                            WriteBack?: number;
                            ReadAhead?: number;
                            UsedIsSize?: boolean;
                            FastFingerprint?: boolean;
                            DiskSpaceTotalSize?: number;
                            HandleCaching?: number;
                            MetadataExtension?: string;
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    pluginsctlAddPlugin: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Repository URL of the plugin to install. */
                    url: string;
                    branch?: string;
                    version?: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    pluginsctlGetPluginsForType: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description MIME type to match when listing plugins. */
                    type?: string;
                    /** @description Filter results by plugin type (e.g. `test`). */
                    pluginType?: string;
                };
            };
        };
        responses: {
            /** @description Loaded plugin metadata for the requested MIME type. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Installed plugins keyed by repository name. */
                        loadedPlugins: {
                            [key: string]: {
                                [key: string]: unknown;
                            };
                        };
                        /** @description Installed test plugins keyed by repository name. */
                        loadedTestPlugins: {
                            [key: string]: {
                                [key: string]: unknown;
                            };
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    pluginsctlListPlugins: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Lists installed production and test plugins with their metadata. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Metadata entries for installed plugins. */
                        loadedPlugins: {
                            [key: string]: unknown;
                        }[];
                        /** @description Metadata entries for installed test plugins. */
                        loadedTestPlugins: {
                            [key: string]: unknown;
                        }[];
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    pluginsctlListTestPlugins: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"];
            };
        };
        responses: {
            /** @description Metadata for installed test plugins keyed by repository name. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description Installed test plugin metadata keyed by repository. */
                        loadedTestPlugins: {
                            [key: string]: {
                                [key: string]: unknown;
                            };
                        };
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    pluginsctlRemovePlugin: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the plugin to uninstall. */
                    name: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    pluginsctlRemoveTestPlugin: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the test plugin to uninstall. */
                    name: string;
                };
            };
        };
        responses: {
            200: components["responses"]["EmptyObjectResponse"];
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
    configUnset: {
        parameters: {
            query?: never;
            header?: {
                /** @description Set to `respond-async` to run the call in the background. Rclone returns a 202 with a job ID right away, and `job/status` reports progress. This has the same effect as the `_async` param in rclone's docs, but `_async` alone returns a 200 instead of a 202. */
                Prefer?: components["parameters"]["PreferAsyncHeader"];
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": components["schemas"]["RcGlobalOptions"] & {
                    /** @description Name of the remote. */
                    name: string;
                    /** @description Key names to remove. */
                    keys: string[];
                };
            };
        };
        responses: {
            /** @description The keys that were removed. */
            200: {
                headers: {
                    "x-rclone-jobid": components["headers"]["RcloneJobId"];
                    [name: string]: unknown;
                };
                content: {
                    "application/json": {
                        /** @description The keys that were removed, or null if none were. */
                        removed: string[] | null;
                    };
                };
            };
            202: components["responses"]["AsyncJobResponse"];
            401: components["responses"]["UnauthorizedResponse"];
            "4XX": components["responses"]["RcError"];
            "5XX": components["responses"]["RcError"];
        };
    };
}