withruntime 0.8.3 → 0.9.0

package/dist/runloop/index.js

@@ -0,0 +1,438 @@
+import { PagePromise, DevboxViewsCursorIDPage } from "./pagination.js";
+import { Sandbox } from "../sandbox.js";
+import { DiskSnapshots, requestOptions, snapshotOptions, snapshotView, nativeOptions, } from "./snapshots.js";
+export { DiskSnapshots, } from "./snapshots.js";
+export { PagePromise, DevboxSnapshotViewsDiskSnapshotsCursorIDPage, DevboxViewsCursorIDPage, } from "./pagination.js";
+import { client, CompatibilityError, create, destroy, execOptions, lookup, only, shellCommand, } from "../compat/core.js";
+export { CompatibilityError };
+export class LongPollAbortError extends Error {
+    lastResult;
+    constructor(message, lastResult) {
+        super(message);
+        this.lastResult = lastResult;
+        this.name = "LongPollAbortError";
+    }
+}
+export class PollingTimeoutError extends Error {
+    lastResult;
+    constructor(message, lastResult) {
+        super(`${message}. Last result: ${JSON.stringify(lastResult, null, 2)}`);
+        this.lastResult = lastResult;
+        this.name = "PollingTimeoutError";
+    }
+}
+export class MaxAttemptsExceededError extends Error {
+    lastResult;
+    constructor(message, lastResult) {
+        super(`${message}. Last result: ${JSON.stringify(lastResult, null, 2)}`);
+        this.lastResult = lastResult;
+        this.name = "MaxAttemptsExceededError";
+    }
+}
+const sizes = {
+    X_SMALL: [0.5, 1024, 4096],
+    SMALL: [1, 2048, 4096],
+    MEDIUM: [2, 4096, 8192],
+    LARGE: [2, 8192, 16384],
+    X_LARGE: [4, 16384, 16384],
+    XX_LARGE: [8, 32768, 16384],
+};
+const result = (id, r) => ({
+    devbox_id: id,
+    exit_status: r.exitCode,
+    stdout: r.stdout,
+    stderr: r.stderr,
+    stdout_truncated: r.stdoutTruncated ?? false,
+    stderr_truncated: r.stderrTruncated ?? false,
+});
+const SUSPENDED = "compat.runloop.suspended";
+function view(sandbox) {
+    const i = sandbox.info;
+    return {
+        id: i.id,
+        name: i.name,
+        metadata: Object.fromEntries(Object.entries(i.labels).filter(([k]) => k !== "compat.provider" && k !== SUSPENDED)),
+        status: i.state === "paused"
+            ? "suspended"
+            : i.state === "stopped"
+                ? i.persistent && i.labels[SUSPENDED] === "true"
+                    ? "suspended"
+                    : "shutdown"
+                : i.state === "stopping" && i.labels[SUSPENDED] === "true"
+                    ? "suspending"
+                    : i.state === "pausing"
+                        ? "suspending"
+                        : i.state === "starting"
+                            ? i.labels[SUSPENDED] === "true"
+                                ? "resuming"
+                                : "provisioning"
+                            : i.state,
+        create_time_ms: Date.parse(i.createdAt),
+        end_time_ms: i.endedAt ? Date.parse(i.endedAt) : null,
+        capabilities: [],
+        state_transitions: [],
+        launch_parameters: {
+            custom_cpu_cores: i.vcpu,
+            custom_gb_memory: i.memoryMiB / 1024,
+            custom_disk_size: i.diskMiB / 1024,
+            keep_alive_time_seconds: i.timeoutSeconds,
+            resource_size_request: "CUSTOM_SIZE",
+        },
+    };
+}
+export class Runloop {
+    devboxes;
+    constructor(options = {}) {
+        const { bearerToken, baseURL, ...rest } = options;
+        this.devboxes = new Devboxes(client({ ...rest, apiKey: rest.apiKey ?? bearerToken, baseUrl: rest.baseUrl ?? baseURL }));
+    }
+}
+export default Runloop;
+export class Devboxes {
+    runtime;
+    executions;
+    diskSnapshots;
+    transitions = new Map();
+    transition(id, operation) {
+        const pending = (this.transitions.get(id) ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(operation);
+        this.transitions.set(id, pending);
+        void pending
+            .finally(() => {
+            if (this.transitions.get(id) === pending)
+                this.transitions.delete(id);
+        })
+            .catch(() => undefined);
+        return pending;
+    }
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.executions = new Executions(runtime);
+        this.diskSnapshots = new DiskSnapshots(runtime);
+    }
+    async create(input = {}, options = {}) {
+        only("Runloop", input, [
+            "name",
+            "metadata",
+            "environment_variables",
+            "file_mounts",
+            "blueprint_id",
+            "blueprint_name",
+            "snapshot_id",
+            "launch_parameters",
+        ]);
+        const p = input.launch_parameters ?? {};
+        only("Runloop launch_parameters", p, [
+            "architecture",
+            "custom_cpu_cores",
+            "custom_gb_memory",
+            "custom_disk_size",
+            "resource_size_request",
+            "keep_alive_time_seconds",
+            "launch_commands",
+        ]);
+        if (p.architecture === "arm64")
+            throw new CompatibilityError("Runloop", "arm64 architecture");
+        if ([input.blueprint_id, input.blueprint_name, input.snapshot_id].filter(Boolean).length > 1)
+            throw new TypeError("Specify only one blueprint or snapshot.");
+        const size = p.resource_size_request && p.resource_size_request !== "CUSTOM_SIZE"
+            ? sizes[p.resource_size_request]
+            : undefined;
+        if ((p.custom_cpu_cores ?? size?.[0]) === 0.5)
+            throw new CompatibilityError("Runloop", "fractional CPU shape; Runtime sandbox CPU counts are whole cores");
+        const sandbox = await create(this.runtime, "runloop", {
+            name: input.name ?? undefined,
+            labels: input.metadata ?? undefined,
+            image: input.blueprint_id ?? input.blueprint_name ?? undefined,
+            snapshot: input.snapshot_id ?? undefined,
+            vcpu: p.custom_cpu_cores ?? size?.[0],
+            memoryMiB: p.custom_gb_memory ? p.custom_gb_memory * 1024 : size?.[1],
+            diskMiB: p.custom_disk_size ? p.custom_disk_size * 1024 : size?.[2],
+            timeoutSeconds: p.keep_alive_time_seconds ?? 3600,
+            idlePauseSeconds: 0,
+            onLeaseEnd: "stop",
+        }, input.environment_variables ?? undefined, async (sandbox) => {
+            for (const [path, content] of Object.entries(input.file_mounts ?? {}))
+                await sandbox.files.write(path, content);
+            for (const command of p.launch_commands ?? [])
+                await sandbox.exec(command, {
+                    ...(await execOptions(sandbox)),
+                    check: true,
+                    signal: options.signal,
+                });
+        });
+        return view(sandbox);
+    }
+    createAndAwaitRunning(input, options) {
+        return this.create(input, options);
+    }
+    async retrieve(id) {
+        return view(await lookup(this.runtime, id));
+    }
+    async awaitRunning(id, options = {}) {
+        return this.waitForStatus(id, "running", options);
+    }
+    awaitDevboxRunning(id, options = {}) {
+        return this.awaitRunning(id, options);
+    }
+    async awaitSuspended(id, options = {}) {
+        return this.waitForStatus(id, "suspended", options);
+    }
+    async waitForStatus(id, target, options) {
+        const timeoutMs = options.longPoll?.timeoutMs ?? options.polling?.timeoutMs;
+        if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs <= 0))
+            throw new Error("timeoutMs must be positive");
+        if (options.signal?.aborted)
+            throw new LongPollAbortError("Long poll aborted", undefined);
+        const deadline = timeoutMs === undefined ? undefined : AbortSignal.timeout(timeoutMs);
+        const signal = deadline && options.signal
+            ? AbortSignal.any([deadline, options.signal])
+            : (deadline ?? options.signal);
+        let lastResult;
+        try {
+            const s = await this.runtime.sandboxes.get(id, { signal, timeoutMs: options.timeout });
+            while (true) {
+                signal?.throwIfAborted();
+                const result = view(s);
+                if (result.status === target)
+                    return result;
+                const transitional = target === "running"
+                    ? ["starting", "resuming"].includes(s.state)
+                    : s.state === "stopping" && s.info.labels[SUSPENDED] === "true";
+                if (!transitional)
+                    throw new Error(`Devbox ${id} is in non-${target} state ${result.status}`);
+                // A status wait never wakes, restarts or otherwise changes a resource.
+                await s.waitFor(target === "running" ? "running" : "stopped", {
+                    signal,
+                    timeoutSeconds: 60,
+                    timeoutMs: options.timeout ?? 65000,
+                });
+                lastResult = view(s);
+            }
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw new LongPollAbortError("Long poll aborted", lastResult);
+            if (deadline?.aborted)
+                throw new PollingTimeoutError(`Long poll timed out after ${timeoutMs}ms`, lastResult);
+            throw error;
+        }
+    }
+    list(query = {}, options = {}) {
+        if (requestOptions(query))
+            return this.list({}, query);
+        return new PagePromise(this.listPage(query, options));
+    }
+    async listPage(query, options) {
+        only("Runloop list", query, [
+            "name",
+            "limit",
+            "starting_after",
+            "metadata",
+            "status",
+            "include_total_count",
+        ]);
+        if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit <= 0))
+            throw new TypeError("limit must be positive");
+        const values = [];
+        let cursor = null;
+        do {
+            const page = await this.runtime.transport.json({
+                method: "GET",
+                path: "/v1/sandboxes",
+                query: {
+                    includeStopped: true,
+                    label: ["compat.provider:runloop"],
+                    cursor: cursor ?? undefined,
+                    limit: 100,
+                },
+                ...nativeOptions(options),
+            });
+            for (const info of page.data) {
+                if (info.labels["compat.provider"] !== "runloop")
+                    continue;
+                const value = view(new Sandbox(this.runtime.transport, info));
+                if ((!query.name || value.name === query.name) &&
+                    (!query.status || value.status === query.status) &&
+                    Object.entries(query.metadata ?? {}).every(([key, expected]) => value.metadata[key] === expected))
+                    values.push(value);
+            }
+            cursor = page.nextCursor;
+        } while (cursor !== null);
+        const offset = query.starting_after
+            ? values.findIndex((value) => value.id === query.starting_after) + 1
+            : 0;
+        if (query.starting_after && offset === 0)
+            throw new TypeError("starting_after does not identify a matching devbox");
+        const data = values.slice(offset, offset + (query.limit ?? 20));
+        return new DevboxViewsCursorIDPage(data, offset + data.length < values.length, query.include_total_count === false ? 0 : values.length, (after) => this.listPage({ ...query, starting_after: after }, options));
+    }
+    suspend(id) {
+        return this.transition(id, async () => {
+            const s = await lookup(this.runtime, id);
+            if (s.state === "stopped") {
+                if (s.info.persistent && s.info.labels[SUSPENDED] === "true")
+                    return view(s);
+                throw new Error("A shut down Devbox cannot be suspended");
+            }
+            // ARCHITECTURE.md section 10: paid disk persistence must be admitted
+            // before stop; an uncertain stop keeps retention enabled to preserve bytes.
+            await s.update({ persistent: true, labels: { ...s.info.labels, [SUSPENDED]: "true" } });
+            await s.stop();
+            return view(s);
+        });
+    }
+    resume(id) {
+        return this.transition(id, async () => {
+            const s = await lookup(this.runtime, id);
+            if (s.state === "stopped") {
+                if (!s.info.persistent || s.info.labels[SUSPENDED] !== "true")
+                    throw new Error("A shut down Devbox cannot be resumed");
+                await s.restart();
+            }
+            else if (s.state === "paused" || s.state === "pausing") {
+                // Migrate older adapter pauses through the same disk-only boundary.
+                await s.update({ persistent: true, labels: { ...s.info.labels, [SUSPENDED]: "true" } });
+                await s.stop();
+                await s.restart();
+            }
+            else
+                await s.waitFor("running");
+            if (s.info.labels[SUSPENDED] !== undefined) {
+                const labels = { ...s.info.labels };
+                delete labels[SUSPENDED];
+                await s.update({ labels });
+            }
+            return view(s);
+        });
+    }
+    shutdown(id) {
+        return this.transition(id, async () => {
+            const s = await lookup(this.runtime, id);
+            await destroy(s);
+            return view(s);
+        });
+    }
+    executeSync(id, body, options) {
+        return this.executions.executeSync(id, body, options);
+    }
+    executeAsync(id, body, options) {
+        return this.executions.executeAsync(id, body, options);
+    }
+    async executeAndAwaitCompletion(id, body, options) {
+        const execution = await this.executeAsync(id, body, options);
+        return this.executions.awaitCompleted(id, execution.execution_id, options);
+    }
+    async readFileContents(id, body) {
+        only("Runloop read", body, ["file_path"]);
+        return (await lookup(this.runtime, id)).files.readText(body.file_path);
+    }
+    async writeFileContents(id, body) {
+        only("Runloop write", body, ["file_path", "contents"]);
+        await (await lookup(this.runtime, id)).files.write(body.file_path, body.contents);
+        return result(id, { stdout: "", stderr: "", exitCode: 0, timedOut: false });
+    }
+    async snapshotDisk(id, body = {}, options = {}) {
+        if (requestOptions(body))
+            return this.snapshotDisk(id, {}, body);
+        const input = snapshotOptions(body);
+        options.signal?.throwIfAborted();
+        return this.transition(id, async () => {
+            const sandbox = await this.runtime.sandboxes.get(id, nativeOptions(options));
+            return snapshotView(await sandbox.snapshot({ ...input, ...nativeOptions(options) }));
+        });
+    }
+    async snapshotDiskAsync(_id, _body, _options) {
+        throw new CompatibilityError("Runloop", "asynchronous snapshot capture; use snapshotDisk until server-side capture/resume coordination is available");
+    }
+    deleteDiskSnapshot(id, options) {
+        return this.diskSnapshots.delete(id, options);
+    }
+    listDiskSnapshots(query = {}, options) {
+        return requestOptions(query)
+            ? this.diskSnapshots.list(query)
+            : this.diskSnapshots.list(query, options);
+    }
+}
+export class Executions {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async executeSync(id, body, options = {}) {
+        only("Runloop execute", body, ["command", "shell_name", "attach_stdin"]);
+        if (body.attach_stdin)
+            throw new TypeError("attach_stdin requires executeAsync");
+        const s = await lookup(this.runtime, id);
+        return result(id, await s.exec(await shellCommand(s, body.command, body.shell_name), await execOptions(s, {
+            signal: options.signal,
+            timeoutMs: options.timeout,
+            idempotencyKey: options.idempotencyKey,
+            onStdout: () => { },
+        })));
+    }
+    async executeAsync(id, body, options = {}) {
+        only("Runloop execute", body, ["command", "shell_name", "attach_stdin"]);
+        if (body.shell_name && body.attach_stdin)
+            throw new CompatibilityError("Runloop", "interactive stdin in a named shell");
+        const s = await lookup(this.runtime, id);
+        const p = await s.spawn(await shellCommand(s, body.command, body.shell_name), {
+            ...(await execOptions(s, { signal: options.signal, idempotencyKey: options.idempotencyKey })),
+            stdin: body.attach_stdin ? "pipe" : undefined,
+        });
+        return { devbox_id: id, execution_id: p.id, status: "running" };
+    }
+    async retrieve(id, execution) {
+        const p = await (await lookup(this.runtime, id)).processes.get(execution);
+        return p.info.state === "running"
+            ? { devbox_id: id, execution_id: execution, status: "running" }
+            : { ...result(id, await p.wait()), execution_id: execution, status: "completed" };
+    }
+    async awaitCompleted(id, execution, options = {}) {
+        const p = await (await lookup(this.runtime, id)).processes.get(execution);
+        return {
+            ...result(id, await p.wait({ signal: options.signal })),
+            execution_id: execution,
+            status: "completed",
+        };
+    }
+    async kill(id, execution, body = {}) {
+        only("Runloop kill", body, ["kill_process_group"]);
+        if (body.kill_process_group)
+            throw new CompatibilityError("Runloop", "kill_process_group");
+        await (await (await lookup(this.runtime, id)).processes.get(execution)).kill("SIGKILL");
+        return this.retrieve(id, execution);
+    }
+    async sendStdIn(id, execution, body = {}) {
+        const p = await (await lookup(this.runtime, id)).processes.get(execution);
+        if (body.text || body.signal === "EOF")
+            await p.write(body.text ?? "", { eof: body.signal === "EOF" });
+        if (body.signal === "INTERRUPT")
+            await p.kill("SIGINT");
+        return { devbox_id: id, execution_id: execution, success: true };
+    }
+    async *streamStdoutUpdates(id, execution, query = {}, options = {}) {
+        yield* this.stream(id, execution, "stdout", query, options);
+    }
+    async *streamStderrUpdates(id, execution, query = {}, options = {}) {
+        yield* this.stream(id, execution, "stderr", query, options);
+    }
+    async *stream(id, execution, channel, query, options) {
+        const p = await (await lookup(this.runtime, id)).processes.get(execution);
+        let offset = 0;
+        const from = Number(query.offset ?? 0);
+        for await (const event of p.output({ signal: options.signal }))
+            if (event.type === channel) {
+                const bytes = new TextEncoder().encode(event.data);
+                if (offset + bytes.length > from)
+                    yield {
+                        output: new TextDecoder().decode(bytes.subarray(Math.max(0, from - offset))),
+                        offset: Math.max(offset, from),
+                    };
+                offset += bytes.length;
+            }
+            else if (event.type === "truncated")
+                throw new Error("Runloop execution output was truncated by the host.");
+    }
+}

package/dist/runloop/pagination.d.ts

@@ -0,0 +1,46 @@
+import type { DevboxSnapshotView } from "./snapshots.js";
+import type { DevboxView } from "./index.js";
+/** Runloop's cursor pages support both awaited pages and unawaited iteration. */
+export declare class CursorPage<T extends {
+    id: string;
+}> implements AsyncIterable<T> {
+    readonly data: T[];
+    readonly has_more: boolean;
+    readonly total_count: number;
+    private readonly fetchNext;
+    constructor(data: T[], has_more: boolean, total_count: number, fetchNext: (after: string) => Promise<CursorPage<T>>);
+    getPaginatedItems(): T[];
+    hasNextPage(): boolean;
+    nextPageInfo(): {
+        params: {
+            starting_after: string;
+        };
+    } | null;
+    nextPageParams(): {
+        starting_after: string;
+    } | null;
+    getNextPage(): Promise<CursorPage<T>>;
+    iterPages(): AsyncGenerator<CursorPage<T>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+}
+export declare class DevboxSnapshotViewsDiskSnapshotsCursorIDPage<T extends {
+    id: string;
+} = DevboxSnapshotView> extends CursorPage<T> {
+    get snapshots(): T[];
+    getNextPage(): Promise<DevboxSnapshotViewsDiskSnapshotsCursorIDPage<T>>;
+    iterPages(): AsyncGenerator<DevboxSnapshotViewsDiskSnapshotsCursorIDPage<T>>;
+}
+export declare class DevboxViewsCursorIDPage<T extends {
+    id: string;
+} = DevboxView> extends CursorPage<T> {
+    get devboxes(): T[];
+    getNextPage(): Promise<DevboxViewsCursorIDPage<T>>;
+    iterPages(): AsyncGenerator<DevboxViewsCursorIDPage<T>>;
+}
+export declare class PagePromise<T extends {
+    id: string;
+}, P extends CursorPage<T>> extends Promise<P> implements AsyncIterable<T> {
+    static get [Symbol.species](): PromiseConstructor;
+    constructor(promise: Promise<P>);
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+}

package/dist/runloop/pagination.js

@@ -0,0 +1,82 @@
+/** Runloop's cursor pages support both awaited pages and unawaited iteration. */
+export class CursorPage {
+    data;
+    has_more;
+    total_count;
+    fetchNext;
+    constructor(data, has_more, total_count, fetchNext) {
+        this.data = data;
+        this.has_more = has_more;
+        this.total_count = total_count;
+        this.fetchNext = fetchNext;
+    }
+    getPaginatedItems() {
+        return this.data;
+    }
+    hasNextPage() {
+        return this.has_more && this.data.length > 0;
+    }
+    nextPageInfo() {
+        const last = this.data.at(-1);
+        return last ? { params: { starting_after: last.id } } : null;
+    }
+    nextPageParams() {
+        return this.nextPageInfo()?.params ?? null;
+    }
+    getNextPage() {
+        const next = this.nextPageInfo();
+        if (!next)
+            return Promise.reject(new Error("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`."));
+        return this.fetchNext(next.params.starting_after);
+    }
+    async *iterPages() {
+        yield this;
+        if (!this.hasNextPage())
+            return;
+        let page = await this.getNextPage();
+        yield page;
+        while (page.hasNextPage()) {
+            page = await page.getNextPage();
+            yield page;
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const page of this.iterPages())
+            yield* page.getPaginatedItems();
+    }
+}
+export class DevboxSnapshotViewsDiskSnapshotsCursorIDPage extends CursorPage {
+    get snapshots() {
+        return this.data;
+    }
+    getNextPage() {
+        return super.getNextPage();
+    }
+    async *iterPages() {
+        for await (const page of super.iterPages())
+            yield page;
+    }
+}
+export class DevboxViewsCursorIDPage extends CursorPage {
+    get devboxes() {
+        return this.data;
+    }
+    getNextPage() {
+        return super.getNextPage();
+    }
+    async *iterPages() {
+        for await (const page of super.iterPages())
+            yield page;
+    }
+}
+export class PagePromise extends Promise {
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    constructor(promise) {
+        super((resolve, reject) => promise.then(resolve, reject));
+    }
+    async *[Symbol.asyncIterator]() {
+        yield* await this;
+    }
+}

package/dist/runloop/snapshots.d.ts

@@ -0,0 +1,52 @@
+import type { Runtime } from "../client.js";
+import type { Snapshot, SnapshotOptions } from "../snapshots.js";
+import { type RequestOptions, type LongPollRequestOptions } from "./index.js";
+import { DevboxSnapshotViewsDiskSnapshotsCursorIDPage, PagePromise } from "./pagination.js";
+export interface DevboxSnapshotDiskParams {
+    name?: string | null;
+    metadata?: Record<string, string> | null;
+    commit_message?: string | null;
+}
+export interface DevboxSnapshotView {
+    id: string;
+    create_time_ms: number;
+    metadata: Record<string, string>;
+    source_devbox_id: string;
+    commit_message?: string | null;
+    name?: string | null;
+    size_bytes?: number | null;
+    source_blueprint_id?: string | null;
+}
+export interface DevboxSnapshotAsyncStatusView {
+    status: "in_progress" | "error" | "complete" | "deleted";
+    error_message?: string | null;
+    snapshot?: DevboxSnapshotView | null;
+}
+export interface DiskSnapshotListParams {
+    starting_after?: string;
+    limit?: number;
+    devbox_id?: string;
+    include_total_count?: boolean;
+    source_blueprint_id?: string;
+    [key: `metadata[${string}]`]: string | undefined;
+}
+export declare function requestOptions(value: object): value is RequestOptions;
+export declare function nativeOptions(options: RequestOptions): {
+    signal: AbortSignal | undefined;
+    timeoutMs: number | undefined;
+    idempotencyKey: string | undefined;
+};
+export declare function snapshotOptions(body: DevboxSnapshotDiskParams): SnapshotOptions;
+export declare function snapshotView(snapshot: Snapshot): DevboxSnapshotView;
+export declare class DiskSnapshots {
+    private readonly runtime;
+    constructor(runtime: Runtime);
+    update(id: string, body?: DevboxSnapshotDiskParams, options?: RequestOptions): Promise<DevboxSnapshotView>;
+    update(id: string, options?: RequestOptions): Promise<DevboxSnapshotView>;
+    awaitCompleted(id: string, options?: LongPollRequestOptions): Promise<DevboxSnapshotAsyncStatusView>;
+    queryStatus(id: string, options?: RequestOptions): Promise<DevboxSnapshotAsyncStatusView>;
+    delete(id: string, options?: RequestOptions): Promise<unknown>;
+    list(query?: DiskSnapshotListParams, options?: RequestOptions): PagePromise<DevboxSnapshotView, DevboxSnapshotViewsDiskSnapshotsCursorIDPage<DevboxSnapshotView>>;
+    list(options?: RequestOptions): PagePromise<DevboxSnapshotView, DevboxSnapshotViewsDiskSnapshotsCursorIDPage<DevboxSnapshotView>>;
+    private page;
+}