@boxrouter/sdk 0.0.0-stage → 0.12.190

package/dist/namespace-terminals.d.mts

@@ -0,0 +1,112 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, ServerSentEventsResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { TerminalsEventsData, TerminalsEventsResponse, TerminalsEventsResponses, TerminalsGetData, TerminalsGetErrors, TerminalsGetResponses, TerminalsKillData, TerminalsKillErrors, TerminalsKillResponses, TerminalsOpenData, TerminalsOpenErrors, TerminalsOpenResponses, TerminalsResizeData, TerminalsResizeErrors, TerminalsResizeResponses, TerminalsWriteData, TerminalsWriteErrors, TerminalsWriteResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+export declare class Terminals extends HeyApiClient {
+    /**
+     * Open a terminal
+     *
+     * Opens a real PTY running a Bash login shell on any active provider. A small
+     * Python 3 helper in the guest owns the PTY, so the sandbox image must provide
+     * `python3`. Opens once and returns a BoxRouter terminal handle; the shell ends at
+     * `timeout_seconds`, on `kill`, when it exits, or with the sandbox. Terminal
+     * connections and output expire on API worker loss; the durable open record still
+     * prevents another dispatch. No automatic recovery or replay.
+     *
+     */
+    open<ThrowOnError extends boolean = true>(options: Options<TerminalsOpenData, ThrowOnError>): RequestResult<TerminalsOpenResponses, TerminalsOpenErrors, ThrowOnError, 'data'>;
+    /**
+     * Get observed terminal state
+     *
+     * Reads an owned terminal record without consuming output.
+     */
+    get<ThrowOnError extends boolean = true>(options: Options<TerminalsGetData, ThrowOnError>): RequestResult<TerminalsGetResponses, TerminalsGetErrors, ThrowOnError, 'data'>;
+    /**
+     * Stream terminal output and its end
+     *
+     * You can rely on:
+     * - Input order is kept and output applies backpressure on PTY routes.
+     * - Closing an observer does not by itself end the process.
+     *
+     * You can set: input, dimensions. Observation controls where supported.
+     *
+     * Not promised: unlimited concurrent observers.
+     *
+     * Server-sent events. Each data field contains one JSON TerminalEvent; the SSE id
+     * is its sequence. Output events carry exact bytes as base64. An exit event follows
+     * all output. An error event may arrive after HTTP 200 and ends the stream without
+     * implying the shell stopped. EOF without an exit or error event is an incomplete
+     * stream, not success.
+     *
+     * Output is retained in a 1 MiB sliding window until 60 seconds after the shell
+     * ends. Last-Event-ID resumes after that event while it is retained; a dropped
+     * sequence returns 410, or an error event for a reader that falls behind, and is
+     * never skipped silently. Without Last-Event-ID the stream starts at the oldest
+     * retained event.
+     *
+     */
+    events<ThrowOnError extends boolean = true>(options: Options<TerminalsEventsData, ThrowOnError, TerminalsEventsResponse>): Promise<ServerSentEventsResult<TerminalsEventsResponses>>;
+    /**
+     * Write terminal input
+     *
+     * You can rely on:
+     * - Input order is kept and output applies backpressure on PTY routes.
+     * - Closing an observer does not by itself end the process.
+     *
+     * You can set: input, dimensions. Observation controls where supported.
+     *
+     * Not promised: unlimited concurrent observers.
+     *
+     * Writes exact bytes to the PTY once. Await calls sequentially to preserve order.
+     * Each call is one command round trip on the provider. An uncertain write must not
+     * be replayed with a new key. Returns 409 after the shell has ended.
+     *
+     */
+    write<ThrowOnError extends boolean = true>(options: Options<TerminalsWriteData, ThrowOnError>): RequestResult<TerminalsWriteResponses, TerminalsWriteErrors, ThrowOnError, 'data'>;
+    /**
+     * Resize the terminal window
+     *
+     * You can rely on:
+     * - Changes the terminal's window size, or is refused where the sandbox cannot resize an open terminal.
+     *
+     * You can set: columns, rows.
+     *
+     * Not promised: when the running program notices the new size.
+     *
+     * The foreground program receives SIGWINCH. Where the sandbox cannot resize an open
+     * terminal, the refusal is `409 capability_unavailable`; open the terminal at the size
+     * you need.
+     *
+     */
+    resize<ThrowOnError extends boolean = true>(options: Options<TerminalsResizeData, ThrowOnError>): RequestResult<TerminalsResizeResponses, TerminalsResizeErrors, ThrowOnError, 'data'>;
+    /**
+     * Hang up the terminal without destroying its sandbox
+     *
+     * You can rely on:
+     * - Ends the terminal's shell without destroying the sandbox, or is refused where the sandbox cannot end it from outside; ending a terminal that already ended succeeds until the terminal expires.
+     *
+     * Not promised: that the shell has already ended when the call returns (its exit event shows when it does); that the whole process group receives the hang-up.
+     *
+     * It sends a hang-up to the shell's process group where the provider allows that, and
+     * otherwise ends the shell process. The terminal's exit event carries the shell's exit
+     * code, or -1 when, after a kill, the provider ends the terminal without reporting one. Closing an
+     * events connection never calls this. Where the sandbox cannot end a terminal's shell from
+     * outside, the refusal is `409 capability_unavailable`; type `exit` in the terminal or
+     * destroy the sandbox. A terminal expires 60 seconds after its shell ends: until then a
+     * kill answers 204, afterwards `410 expired`.
+     *
+     */
+    kill<ThrowOnError extends boolean = true>(options: Options<TerminalsKillData, ThrowOnError>): RequestResult<TerminalsKillResponses, TerminalsKillErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-terminals.mjs

@@ -0,0 +1,177 @@
+import { validateEvent, withEventValidators } from "./core/eventValidation.js";
+import { HeyApiClient } from './namespace-base.mjs';
+export class Terminals extends HeyApiClient {
+    /**
+     * Open a terminal
+     *
+     * Opens a real PTY running a Bash login shell on any active provider. A small
+     * Python 3 helper in the guest owns the PTY, so the sandbox image must provide
+     * `python3`. Opens once and returns a BoxRouter terminal handle; the shell ends at
+     * `timeout_seconds`, on `kill`, when it exits, or with the sandbox. Terminal
+     * connections and output expire on API worker loss; the durable open record still
+     * prevents another dispatch. No automatic recovery or replay.
+     *
+     */
+    open(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Get observed terminal state
+     *
+     * Reads an owned terminal record without consuming output.
+     */
+    get(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}',
+            ...options
+        });
+    }
+    /**
+     * Stream terminal output and its end
+     *
+     * You can rely on:
+     * - Input order is kept and output applies backpressure on PTY routes.
+     * - Closing an observer does not by itself end the process.
+     *
+     * You can set: input, dimensions. Observation controls where supported.
+     *
+     * Not promised: unlimited concurrent observers.
+     *
+     * Server-sent events. Each data field contains one JSON TerminalEvent; the SSE id
+     * is its sequence. Output events carry exact bytes as base64. An exit event follows
+     * all output. An error event may arrive after HTTP 200 and ends the stream without
+     * implying the shell stopped. EOF without an exit or error event is an incomplete
+     * stream, not success.
+     *
+     * Output is retained in a 1 MiB sliding window until 60 seconds after the shell
+     * ends. Last-Event-ID resumes after that event while it is retained; a dropped
+     * sequence returns 410, or an error event for a reader that falls behind, and is
+     * never skipped silently. Without Last-Event-ID the stream starts at the oldest
+     * retained event.
+     *
+     */
+    events(options) {
+        return withEventValidators(({ signal: (options.client ?? this.client).getConfig().signal, ...options }).signal, eventValidators => (options.client ?? this.client).sse.get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/events',
+            ...options,
+            ...validateEvent("SandboxTerminalEventSSE", eventValidators.validate0, options.responseValidator ?? (options.client ?? this.client).getConfig().responseValidator, ["exit", "error"], void 0, ["error", "exit", "output"])
+        }));
+    }
+    /**
+     * Write terminal input
+     *
+     * You can rely on:
+     * - Input order is kept and output applies backpressure on PTY routes.
+     * - Closing an observer does not by itself end the process.
+     *
+     * You can set: input, dimensions. Observation controls where supported.
+     *
+     * Not promised: unlimited concurrent observers.
+     *
+     * Writes exact bytes to the PTY once. Await calls sequentially to preserve order.
+     * Each call is one command round trip on the provider. An uncertain write must not
+     * be replayed with a new key. Returns 409 after the shell has ended.
+     *
+     */
+    write(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/input',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Resize the terminal window
+     *
+     * You can rely on:
+     * - Changes the terminal's window size, or is refused where the sandbox cannot resize an open terminal.
+     *
+     * You can set: columns, rows.
+     *
+     * Not promised: when the running program notices the new size.
+     *
+     * The foreground program receives SIGWINCH. Where the sandbox cannot resize an open
+     * terminal, the refusal is `409 capability_unavailable`; open the terminal at the size
+     * you need.
+     *
+     */
+    resize(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/resize',
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+    }
+    /**
+     * Hang up the terminal without destroying its sandbox
+     *
+     * You can rely on:
+     * - Ends the terminal's shell without destroying the sandbox, or is refused where the sandbox cannot end it from outside; ending a terminal that already ended succeeds until the terminal expires.
+     *
+     * Not promised: that the shell has already ended when the call returns (its exit event shows when it does); that the whole process group receives the hang-up.
+     *
+     * It sends a hang-up to the shell's process group where the provider allows that, and
+     * otherwise ends the shell process. The terminal's exit event carries the shell's exit
+     * code, or -1 when, after a kill, the provider ends the terminal without reporting one. Closing an
+     * events connection never calls this. Where the sandbox cannot end a terminal's shell from
+     * outside, the refusal is `409 capability_unavailable`; type `exit` in the terminal or
+     * destroy the sandbox. A terminal expires 60 seconds after its shell ends: until then a
+     * kill answers 204, afterwards `410 expired`.
+     *
+     */
+    kill(options) {
+        return (options.client ?? this.client).post({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/sandboxes/{sandbox_id}/terminals/{terminal_id}/kill',
+            ...options
+        });
+    }
+}

package/dist/namespace-usage.d.mts

@@ -0,0 +1,46 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { UsageExportCsvData, UsageExportCsvErrors, UsageExportCsvResponses, UsageListData, UsageListErrors, UsageListResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+export declare class Usage extends HeyApiClient {
+    /**
+     * List grouped managed and BYOK sandbox usage
+     *
+     * Requires account-management permission; execution-only keys receive 403. Reads
+     * only this workspace and the configured test or live billing book. Settled managed
+     * charges come from verified ledger receipts and are recognized on their settlement
+     * date. BYOK costs come from the provider's own cost or usage records priced at
+     * stored list rates. byok_provider_cost_usd is that exact amount or null, never a
+     * local-clock cost or partial subtotal. No BYOK fee is included because its price-book policy remains
+     * proposed and unapproved. Current managed reservations are reported as held amounts;
+     * with group_by=day they appear under period and group_key `current`, outside the
+     * requested historical date range. Dates are inclusive UTC calendar dates and the
+     * range may not exceed 92 days. Unknown observations remain null and are counted in
+     * the corresponding unknown-sandbox field; a BYOK cost is null when any contributing
+     * sandbox's provider cost is unknown. The optional provider filter is applied
+     * before grouping to managed and BYOK history and to current managed holds. Cursors
+     * are scoped to workspace, billing mode and all report filters; malformed or foreign
+     * cursors return 400. No provider or
+     * payment-provider calls are made.
+     *
+     */
+    list<ThrowOnError extends boolean = true>(options: Options<UsageListData, ThrowOnError>): RequestResult<UsageListResponses, UsageListErrors, ThrowOnError, 'data'>;
+    /**
+     * Export grouped managed and BYOK sandbox usage as CSV
+     *
+     * Uses the same workspace, billing mode, date range, filters and page as the JSON usage report. CSV values preserve the JSON report's exact decimal strings; `X-Usage-As-Of` identifies the observation time and `X-Next-Cursor` is present when another page exists.
+     */
+    exportCsv<ThrowOnError extends boolean = true>(options: Options<UsageExportCsvData, ThrowOnError>): RequestResult<UsageExportCsvResponses, UsageExportCsvErrors, ThrowOnError, 'data'>;
+}

package/dist/namespace-usage.mjs

@@ -0,0 +1,53 @@
+import { HeyApiClient } from './namespace-base.mjs';
+export class Usage extends HeyApiClient {
+    /**
+     * List grouped managed and BYOK sandbox usage
+     *
+     * Requires account-management permission; execution-only keys receive 403. Reads
+     * only this workspace and the configured test or live billing book. Settled managed
+     * charges come from verified ledger receipts and are recognized on their settlement
+     * date. BYOK costs come from the provider's own cost or usage records priced at
+     * stored list rates. byok_provider_cost_usd is that exact amount or null, never a
+     * local-clock cost or partial subtotal. No BYOK fee is included because its price-book policy remains
+     * proposed and unapproved. Current managed reservations are reported as held amounts;
+     * with group_by=day they appear under period and group_key `current`, outside the
+     * requested historical date range. Dates are inclusive UTC calendar dates and the
+     * range may not exceed 92 days. Unknown observations remain null and are counted in
+     * the corresponding unknown-sandbox field; a BYOK cost is null when any contributing
+     * sandbox's provider cost is unknown. The optional provider filter is applied
+     * before grouping to managed and BYOK history and to current managed holds. Cursors
+     * are scoped to workspace, billing mode and all report filters; malformed or foreign
+     * cursors return 400. No provider or
+     * payment-provider calls are made.
+     *
+     */
+    list(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/usage',
+            ...options
+        });
+    }
+    /**
+     * Export grouped managed and BYOK sandbox usage as CSV
+     *
+     * Uses the same workspace, billing mode, date range, filters and page as the JSON usage report. CSV values preserve the JSON report's exact decimal strings; `X-Usage-As-Of` identifies the observation time and `X-Next-Cursor` is present when another page exists.
+     */
+    exportCsv(options) {
+        return (options.client ?? this.client).get({
+            responseStyle: 'data',
+            security: [{ scheme: 'bearer', type: 'http' }, {
+                    in: 'cookie',
+                    name: '__Host-boxrouter_session',
+                    type: 'apiKey'
+                }],
+            url: '/usage.csv',
+            ...options
+        });
+    }
+}

package/dist/namespace-volumes.d.mts

@@ -0,0 +1,110 @@
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client/index.js';
+import { HeyApiClient } from './namespace-base.mjs';
+import type { VolumesAbortUploadData, VolumesAbortUploadErrors, VolumesAbortUploadResponses, VolumesCompleteUploadData, VolumesCompleteUploadErrors, VolumesCompleteUploadResponses, VolumesCreateData, VolumesCreateDownloadData, VolumesCreateDownloadErrors, VolumesCreateDownloadResponses, VolumesCreateErrors, VolumesCreateResponses, VolumesCreateUploadData, VolumesCreateUploadErrors, VolumesCreateUploadResponses, VolumesDeleteCheckpointData, VolumesDeleteCheckpointErrors, VolumesDeleteCheckpointResponses, VolumesDeleteData, VolumesDeleteErrors, VolumesDeleteResponses, VolumesGetCheckpointData, VolumesGetCheckpointErrors, VolumesGetCheckpointResponses, VolumesGetData, VolumesGetErrors, VolumesGetResponses, VolumesListCheckpointsData, VolumesListCheckpointsErrors, VolumesListCheckpointsResponses, VolumesListData, VolumesListErrors, VolumesListFilesData, VolumesListFilesErrors, VolumesListFilesResponses, VolumesListResponses, VolumesReleaseData, VolumesReleaseErrors, VolumesReleaseResponses, VolumesSaveData, VolumesSaveErrors, VolumesSaveResponses } from './types.gen.js';
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+export declare class Volumes extends HeyApiClient {
+    /**
+     * List volumes
+     *
+     * Lists volumes in the caller's workspace using cursor-based pagination. The response includes the current storage usage and live-volume policy only when those values are available.
+     */
+    list<ThrowOnError extends boolean = true>(options?: Options<VolumesListData, ThrowOnError>): RequestResult<VolumesListResponses, VolumesListErrors, ThrowOnError, 'data'>;
+    /**
+     * Create a volume
+     *
+     * The service selects its configured live backend when this workspace's live-volume policy allows creation. Backend identity is neither a request field nor a response label.
+     */
+    create<ThrowOnError extends boolean = true>(options: Options<VolumesCreateData, ThrowOnError>): RequestResult<VolumesCreateResponses, VolumesCreateErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete a volume and its checkpoints
+     *
+     * Deletes a volume and all checkpoint references and stored bytes for it. When the volume's writer is ending (its destroy was accepted), the call waits for the release, at most 120 seconds, before deleting. A running writer fails at once with volume_busy (409). Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain result; a conflicting active use can return 409.
+     */
+    delete<ThrowOnError extends boolean = true>(options: Options<VolumesDeleteData, ThrowOnError>): RequestResult<VolumesDeleteResponses, VolumesDeleteErrors, ThrowOnError, 'data'>;
+    /**
+     * Get a volume
+     *
+     * Returns metadata for a BoxRouter-managed volume in the caller's workspace.
+     */
+    get<ThrowOnError extends boolean = true>(options: Options<VolumesGetData, ThrowOnError>): RequestResult<VolumesGetResponses, VolumesGetErrors, ThrowOnError, 'data'>;
+    /**
+     * List volume checkpoints
+     *
+     * Lists committed checkpoints for this volume, newest first. A checkpoint created by an in-progress save is not listed until the save commits.
+     */
+    listCheckpoints<ThrowOnError extends boolean = true>(options: Options<VolumesListCheckpointsData, ThrowOnError>): RequestResult<VolumesListCheckpointsResponses, VolumesListCheckpointsErrors, ThrowOnError, 'data'>;
+    /**
+     * Save a volume checkpoint
+     *
+     * Saves the current volume filesystem as an immutable checkpoint. The optional sandbox_id identifies the expected writer-lease holder; if omitted, the current holder is used. A mounted branch sandbox can be named to checkpoint its branch files without advancing the source volume's head. Read-only sandboxes cannot save. Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain response.
+     */
+    save<ThrowOnError extends boolean = true>(options: Options<VolumesSaveData, ThrowOnError>): RequestResult<VolumesSaveResponses, VolumesSaveErrors, ThrowOnError, 'data'>;
+    /**
+     * Delete a checkpoint
+     *
+     * Removes the checkpoint reference. Backend data is reclaimed when the volume is erased.
+     */
+    deleteCheckpoint<ThrowOnError extends boolean = true>(options: Options<VolumesDeleteCheckpointData, ThrowOnError>): RequestResult<VolumesDeleteCheckpointResponses, VolumesDeleteCheckpointErrors, ThrowOnError, 'data'>;
+    /**
+     * Get a volume checkpoint
+     *
+     * Returns an immutable committed checkpoint by its volume ID and checkpoint number.
+     */
+    getCheckpoint<ThrowOnError extends boolean = true>(options: Options<VolumesGetCheckpointData, ThrowOnError>): RequestResult<VolumesGetCheckpointResponses, VolumesGetCheckpointErrors, ThrowOnError, 'data'>;
+    /**
+     * Release a volume's writer lease
+     *
+     * Releases the volume's writer lease and advances its epoch, invalidating the former writer's lease token. Reuse a supplied Idempotency-Key with the identical request to reconcile an uncertain result.
+     */
+    release<ThrowOnError extends boolean = true>(options: Options<VolumesReleaseData, ThrowOnError>): RequestResult<VolumesReleaseResponses, VolumesReleaseErrors, ThrowOnError, 'data'>;
+    /**
+     * Create a volume file upload
+     *
+     * Creates a multipart upload for a file that will appear at
+     * `/workspace/<path>` in sandboxes. Upload every returned part URL with an
+     * HTTP PUT containing exactly that part's bytes; save the response `ETag`
+     * header for the completion request. Part URLs expire after six hours.
+     * An open upload blocks `write` sandboxes, and a live or pending `write`
+     * attachment blocks uploads (`volume_busy`). `read` and `shared` attachments
+     * may coexist, but their sandboxes may need to refresh their volume cache to
+     * see the new file.
+     *
+     */
+    createUpload<ThrowOnError extends boolean = true>(options: Options<VolumesCreateUploadData, ThrowOnError>): RequestResult<VolumesCreateUploadResponses, VolumesCreateUploadErrors, ThrowOnError, 'data'>;
+    /**
+     * Complete a volume file upload
+     *
+     * Supply each part number exactly once with the `ETag` header returned by its PUT response.
+     */
+    completeUpload<ThrowOnError extends boolean = true>(options: Options<VolumesCompleteUploadData, ThrowOnError>): RequestResult<VolumesCompleteUploadResponses, VolumesCompleteUploadErrors, ThrowOnError, 'data'>;
+    /**
+     * Abort a volume file upload
+     *
+     * Aborts an open multipart upload for this volume. Repeating an abort is safe; the uploaded file is not made visible in the volume.
+     */
+    abortUpload<ThrowOnError extends boolean = true>(options: Options<VolumesAbortUploadData, ThrowOnError>): RequestResult<VolumesAbortUploadResponses, VolumesAbortUploadErrors, ThrowOnError, 'data'>;
+    /**
+     * Create a volume file download
+     *
+     * Creates a temporary download link that expires after one hour.
+     */
+    createDownload<ThrowOnError extends boolean = true>(options: Options<VolumesCreateDownloadData, ThrowOnError>): RequestResult<VolumesCreateDownloadResponses, VolumesCreateDownloadErrors, ThrowOnError, 'data'>;
+    /**
+     * List files in a volume
+     *
+     * Recursively lists files in path order without a directory delimiter. Read and shared sandboxes may need to refresh their volume cache to see new files.
+     */
+    listFiles<ThrowOnError extends boolean = true>(options: Options<VolumesListFilesData, ThrowOnError>): RequestResult<VolumesListFilesResponses, VolumesListFilesErrors, ThrowOnError, 'data'>;
+}