@brimble/sandbox 0.1.0

package/dist/src/resources/sandboxes.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxesResource = void 0;
+const constants_1 = require("../constants");
+const enums_1 = require("../enums");
+const pagination_1 = require("../transport/pagination");
+const sandbox_handle_1 = require("./sandbox-handle");
+const scoped_sandbox_1 = require("./scoped-sandbox");
+const volumes_1 = require("./volumes");
+class SandboxesResource {
+    transport;
+    volumes;
+    /** @internal Create the sandboxes resource wrapper. */
+    constructor(transport) {
+        this.transport = transport;
+        this.volumes = new volumes_1.VolumesResource(transport);
+    }
+    /**
+     * Create a new sandbox.
+     * Region is optional; when omitted this SDK picks the first available region.
+     * The sandbox starts asynchronously, so fetch it until `status` is `ready`
+     * before running commands or file operations.
+     */
+    async create(input, options) {
+        const region = await this.resolveRegionId(input.region, options);
+        const body = {
+            ...input,
+            region,
+        };
+        const result = (await this.transport.requestJson({
+            endpoint: '/sandboxes',
+            method: 'POST',
+            body,
+            ...options,
+        }));
+        return new sandbox_handle_1.SandboxHandle(this, result);
+    }
+    /** Create a sandbox and wait until it is `ready` before returning it. */
+    async createReady(input, options = {}) {
+        const sandbox = await this.create(input, options.request);
+        await sandbox.waitUntilReady(options.wait);
+        return sandbox;
+    }
+    /**
+     * Create a volume and then create a sandbox attached to that volume.
+     * This is the one-call helper for persistent sandbox workflows.
+     */
+    async withVolume(input, options) {
+        const region = await this.resolveRegionId(input.sandbox.region ?? input.volume.region, options);
+        const volume = await this.volumes.create({
+            ...input.volume,
+            region,
+            type: enums_1.VolumeType.Sandbox,
+        }, options);
+        return this.create({
+            ...input.sandbox,
+            region,
+            volumeId: volume.id,
+        }, options);
+    }
+    /** Create a sandbox-scoped volume with package-level defaults and validation. */
+    createVolume(input, options) {
+        return this.volumes.create(input, options);
+    }
+    /** List your sandboxes with pagination. */
+    async list(query = {}, options) {
+        const page = await this.listData(query, options);
+        return {
+            ...page,
+            data: page.data.map((sandbox) => new sandbox_handle_1.SandboxHandle(this, sandbox)),
+        };
+    }
+    /** Iterate over all sandbox handles across paginated results. */
+    async *iterate(query = {}, options) {
+        const limit = query.limit ?? constants_1.DEFAULT_PAGE_LIMIT;
+        let page = query.page ?? constants_1.DEFAULT_PAGE;
+        while (true) {
+            const paginated = await this.list({ ...query, page, limit }, options);
+            for (const sandbox of paginated.data) {
+                yield sandbox;
+            }
+            if (page >= paginated.totalPages || paginated.data.length === 0) {
+                return;
+            }
+            page += 1;
+        }
+    }
+    /** Fetch one sandbox handle by id. */
+    async get(sandboxId, options) {
+        const sandbox = await this.getData(sandboxId, options);
+        return new sandbox_handle_1.SandboxHandle(this, sandbox);
+    }
+    /** Fetch one sandbox and wait for `ready` before returning the handle. */
+    async getReady(sandboxId, options = {}) {
+        const sandbox = await this.get(sandboxId, options.request);
+        await sandbox.waitUntilReady(options.wait);
+        return sandbox;
+    }
+    /** @internal Fetch raw sandbox payload by id. */
+    getData(sandboxId, options) {
+        return this.transport.requestJson({
+            endpoint: `/sandboxes/${sandboxId}`,
+            method: 'GET',
+            ...options,
+        });
+    }
+    /** @internal Fetch raw paginated sandbox payload. */
+    listData(query = {}, options) {
+        const params = (0, pagination_1.toPaginationQuery)(query);
+        if (query.teamId) {
+            params.set('teamId', query.teamId);
+        }
+        return this.transport.requestJson({
+            endpoint: '/sandboxes',
+            method: 'GET',
+            query: params,
+            ...options,
+        });
+    }
+    /** List regions where sandboxes can be provisioned. */
+    listRegions(options) {
+        return this.transport.requestJson({
+            endpoint: '/sandboxes/regions',
+            method: 'GET',
+            ...options,
+        });
+    }
+    /** List sandbox templates available for create operations. */
+    async listTemplates(options) {
+        const payload = await this.transport.requestJson({
+            endpoint: '/sandbox/templates',
+            method: 'GET',
+            ...options,
+        });
+        if (Array.isArray(payload)) {
+            return payload;
+        }
+        if (payload && typeof payload === 'object' && 'templates' in payload) {
+            const templates = payload.templates;
+            if (Array.isArray(templates)) {
+                return templates;
+            }
+        }
+        return [];
+    }
+    /** Fetch one template by name from the template catalog. */
+    async getTemplate(templateName, options) {
+        const templates = await this.listTemplates(options);
+        return templates.find((template) => template.name === templateName);
+    }
+    /** Destroy a sandbox (idempotent). */
+    async destroy(sandboxId, options) {
+        await this.transport.requestJson({
+            endpoint: `/sandboxes/${sandboxId}`,
+            method: 'DELETE',
+            ...options,
+        });
+    }
+    /** Request sandbox pause. */
+    pause(sandboxId, options) {
+        return this.transport.requestJson({
+            endpoint: `/sandboxes/${sandboxId}/pause`,
+            method: 'POST',
+            ...options,
+        });
+    }
+    /** Request sandbox resume. */
+    resume(sandboxId, options) {
+        return this.transport.requestJson({
+            endpoint: `/sandboxes/${sandboxId}/resume`,
+            method: 'POST',
+            ...options,
+        });
+    }
+    /** Use runtime operations for a specific sandbox id. */
+    use(sandboxId) {
+        return new scoped_sandbox_1.ScopedSandboxResource(this.transport, sandboxId);
+    }
+    /** Opinionated Node.js quickstart (persistent sandbox + optional wait). */
+    async quickstartNode(input = {}, options) {
+        return this.quickstart({
+            ...input,
+            template: input.template ?? 'node-22',
+            persistentDiskGB: input.persistentDiskGB ?? 20,
+        }, options);
+    }
+    /** Opinionated Python quickstart (persistent sandbox + optional wait). */
+    async quickstartPython(input = {}, options) {
+        return this.quickstart({
+            ...input,
+            template: input.template ?? 'python-3.12',
+            persistentDiskGB: input.persistentDiskGB ?? 20,
+        }, options);
+    }
+    async quickstart(input, options) {
+        const { waitUntilReady, persistentDiskGB, ...createInput } = input;
+        const sandbox = await this.create({
+            ...createInput,
+            persistent: true,
+            persistentDiskGB,
+        }, options);
+        if (waitUntilReady === false) {
+            return sandbox;
+        }
+        if (typeof waitUntilReady === 'object') {
+            await sandbox.waitUntilReady(waitUntilReady);
+            return sandbox;
+        }
+        await sandbox.waitUntilReady();
+        return sandbox;
+    }
+    async resolveRegionId(region, options) {
+        if (region && region !== 'auto') {
+            return region;
+        }
+        const { regions } = await this.listRegions(options);
+        const regionId = regions[0]?.id;
+        if (!regionId) {
+            throw new Error('No sandbox regions available for this account.');
+        }
+        return regionId;
+    }
+}
+exports.SandboxesResource = SandboxesResource;

package/dist/src/resources/scoped-sandbox.d.ts

@@ -0,0 +1,39 @@
+import { ExecResource } from './exec';
+import { FilesResource } from './files';
+import { SnapshotScopeResource } from './snapshots';
+import { StatsResource } from './stats';
+import { HttpTransport } from '../transport/http';
+import type { CodeInput, CreateSnapshotInput, ExecInput, ExecResult, FileUploadBody, Paginated, Pagination, Snapshot, Stats, StatsQuery } from '../types';
+import type { RequestOptions } from '../transport/http';
+export declare class ScopedSandboxResource {
+    /** Lower-level exec/code runner resource. */
+    readonly execResource: ExecResource;
+    /** File upload/download resource. */
+    readonly files: FilesResource;
+    /** Snapshot resource scoped to this sandbox. */
+    readonly snapshots: SnapshotScopeResource;
+    /** Stats resource scoped to this sandbox. */
+    readonly statsResource: StatsResource;
+    /** @internal Create a sandbox-scoped resource wrapper. */
+    constructor(transport: HttpTransport, sandboxId: string);
+    /** Run a shell command in this sandbox. */
+    exec(input: ExecInput & {
+        stream: true;
+    }, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+    exec(input: ExecInput, options?: RequestOptions): Promise<ExecResult>;
+    /** Run a code snippet in this sandbox. */
+    runCode(input: CodeInput & {
+        stream: true;
+    }, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+    runCode(input: CodeInput, options?: RequestOptions): Promise<ExecResult>;
+    /** Upload bytes to a file path inside this sandbox. */
+    putFile(path: string, body: FileUploadBody, options?: RequestOptions): Promise<void>;
+    /** Download file bytes from this sandbox as a stream. */
+    getFile(path: string, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+    /** Fetch CPU, memory, and network stats for this sandbox. */
+    stats(query?: StatsQuery, options?: RequestOptions): Promise<Stats>;
+    /** Create a snapshot for this sandbox. */
+    createSnapshot(input: CreateSnapshotInput, options?: RequestOptions): Promise<Snapshot>;
+    /** List snapshots for this sandbox. */
+    listSnapshots(query?: Pagination, options?: RequestOptions): Promise<Paginated<Snapshot>>;
+}

package/dist/src/resources/scoped-sandbox.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopedSandboxResource = void 0;
+const exec_1 = require("./exec");
+const files_1 = require("./files");
+const snapshots_1 = require("./snapshots");
+const stats_1 = require("./stats");
+class ScopedSandboxResource {
+    /** Lower-level exec/code runner resource. */
+    execResource;
+    /** File upload/download resource. */
+    files;
+    /** Snapshot resource scoped to this sandbox. */
+    snapshots;
+    /** Stats resource scoped to this sandbox. */
+    statsResource;
+    /** @internal Create a sandbox-scoped resource wrapper. */
+    constructor(transport, sandboxId) {
+        this.execResource = new exec_1.ExecResource(transport, sandboxId);
+        this.files = new files_1.FilesResource(transport, sandboxId);
+        this.snapshots = new snapshots_1.SnapshotScopeResource(transport, sandboxId);
+        this.statsResource = new stats_1.StatsResource(transport, sandboxId);
+    }
+    exec(input, options) {
+        return this.execResource.exec(input, options);
+    }
+    runCode(input, options) {
+        return this.execResource.runCode(input, options);
+    }
+    /** Upload bytes to a file path inside this sandbox. */
+    putFile(path, body, options) {
+        return this.files.put(path, body, options);
+    }
+    /** Download file bytes from this sandbox as a stream. */
+    getFile(path, options) {
+        return this.files.get(path, options);
+    }
+    /** Fetch CPU, memory, and network stats for this sandbox. */
+    stats(query = {}, options) {
+        return this.statsResource.stats(query, options);
+    }
+    /** Create a snapshot for this sandbox. */
+    createSnapshot(input, options) {
+        return this.snapshots.create(input, options);
+    }
+    /** List snapshots for this sandbox. */
+    listSnapshots(query = {}, options) {
+        return this.snapshots.list(query, options);
+    }
+}
+exports.ScopedSandboxResource = ScopedSandboxResource;

package/dist/src/resources/snapshots.d.ts

@@ -0,0 +1,26 @@
+import type { RequestOptions } from '../transport/http';
+import { HttpTransport } from '../transport/http';
+import type { CreateSnapshotInput, Paginated, Pagination, Snapshot } from '../types';
+export declare class SnapshotScopeResource {
+    private readonly transport;
+    private readonly sandboxId;
+    /** @internal Create a sandbox-scoped snapshots wrapper. */
+    constructor(transport: HttpTransport, sandboxId: string);
+    /** Create a snapshot for this specific sandbox. */
+    create(input: CreateSnapshotInput, options?: RequestOptions): Promise<Snapshot>;
+    /** List snapshots for this specific sandbox. */
+    list(query?: Pagination, options?: RequestOptions): Promise<Paginated<Snapshot>>;
+    /** Iterate over all snapshots for this sandbox across pages. */
+    iterate(query?: Pagination, options?: RequestOptions): AsyncGenerator<Snapshot>;
+}
+export declare class SnapshotsResource {
+    private readonly transport;
+    /** @internal Create the global snapshots resource wrapper. */
+    constructor(transport: HttpTransport);
+    /** List all snapshots owned by the current caller. */
+    listAll(query?: Pagination, options?: RequestOptions): Promise<Paginated<Snapshot>>;
+    /** Iterate over all snapshots owned by the caller across pages. */
+    iterateAll(query?: Pagination, options?: RequestOptions): AsyncGenerator<Snapshot>;
+    /** Delete a snapshot by id. */
+    delete(snapshotId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/src/resources/snapshots.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotsResource = exports.SnapshotScopeResource = void 0;
+const pagination_1 = require("../transport/pagination");
+const constants_1 = require("../constants");
+class SnapshotScopeResource {
+    transport;
+    sandboxId;
+    /** @internal Create a sandbox-scoped snapshots wrapper. */
+    constructor(transport, sandboxId) {
+        this.transport = transport;
+        this.sandboxId = sandboxId;
+    }
+    /** Create a snapshot for this specific sandbox. */
+    create(input, options) {
+        return this.transport.requestJson({
+            endpoint: `/sandboxes/${this.sandboxId}/snapshots`,
+            method: 'POST',
+            body: input,
+            ...options,
+        });
+    }
+    /** List snapshots for this specific sandbox. */
+    list(query = {}, options) {
+        return this.transport.requestJson({
+            endpoint: `/sandboxes/${this.sandboxId}/snapshots`,
+            method: 'GET',
+            query: (0, pagination_1.toPaginationQuery)(query),
+            ...options,
+        });
+    }
+    /** Iterate over all snapshots for this sandbox across pages. */
+    async *iterate(query = {}, options) {
+        const limit = query.limit ?? constants_1.DEFAULT_PAGE_LIMIT;
+        let page = query.page ?? constants_1.DEFAULT_PAGE;
+        while (true) {
+            const paginated = await this.list({ ...query, page, limit }, options);
+            for (const snapshot of paginated.data) {
+                yield snapshot;
+            }
+            if (page >= paginated.totalPages || paginated.data.length === 0) {
+                return;
+            }
+            page += 1;
+        }
+    }
+}
+exports.SnapshotScopeResource = SnapshotScopeResource;
+class SnapshotsResource {
+    transport;
+    /** @internal Create the global snapshots resource wrapper. */
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** List all snapshots owned by the current caller. */
+    listAll(query = {}, options) {
+        return this.transport.requestJson({
+            endpoint: '/sandboxes/snapshots',
+            method: 'GET',
+            query: (0, pagination_1.toPaginationQuery)(query),
+            ...options,
+        });
+    }
+    /** Iterate over all snapshots owned by the caller across pages. */
+    async *iterateAll(query = {}, options) {
+        const limit = query.limit ?? constants_1.DEFAULT_PAGE_LIMIT;
+        let page = query.page ?? constants_1.DEFAULT_PAGE;
+        while (true) {
+            const paginated = await this.listAll({ ...query, page, limit }, options);
+            for (const snapshot of paginated.data) {
+                yield snapshot;
+            }
+            if (page >= paginated.totalPages || paginated.data.length === 0) {
+                return;
+            }
+            page += 1;
+        }
+    }
+    /** Delete a snapshot by id. */
+    async delete(snapshotId, options) {
+        await this.transport.requestJson({
+            endpoint: `/sandboxes/snapshots/${snapshotId}`,
+            method: 'DELETE',
+            ...options,
+        });
+    }
+}
+exports.SnapshotsResource = SnapshotsResource;

package/dist/src/resources/stats.d.ts

@@ -0,0 +1,11 @@
+import type { Stats, StatsQuery } from '../types';
+import type { RequestOptions } from '../transport/http';
+import { HttpTransport } from '../transport/http';
+export declare class StatsResource {
+    private readonly transport;
+    private readonly sandboxId;
+    /** @internal Create the stats wrapper for one sandbox. */
+    constructor(transport: HttpTransport, sandboxId: string);
+    /** Fetch sandbox usage stats for a lookback window. */
+    stats(query?: StatsQuery, options?: RequestOptions): Promise<Stats>;
+}

package/dist/src/resources/stats.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsResource = void 0;
+class StatsResource {
+    transport;
+    sandboxId;
+    /** @internal Create the stats wrapper for one sandbox. */
+    constructor(transport, sandboxId) {
+        this.transport = transport;
+        this.sandboxId = sandboxId;
+    }
+    /** Fetch sandbox usage stats for a lookback window. */
+    stats(query = {}, options) {
+        const params = new URLSearchParams();
+        if (query.hoursAgo !== undefined) {
+            params.set('hoursAgo', String(query.hoursAgo));
+        }
+        return this.transport.requestJson({
+            endpoint: `/sandboxes/${this.sandboxId}/stats`,
+            method: 'GET',
+            query: params,
+            ...options,
+        });
+    }
+}
+exports.StatsResource = StatsResource;

package/dist/src/resources/volumes.d.ts

@@ -0,0 +1,21 @@
+import type { RequestOptions } from '../transport/http';
+import { HttpTransport } from '../transport/http';
+import type { CreateVolumeInput, Paginated, TeamScopedPagination, Volume } from '../types';
+export declare class VolumesResource {
+    private readonly transport;
+    /** @internal Create the volumes resource wrapper. */
+    constructor(transport: HttpTransport);
+    /** List your volumes with pagination. */
+    list(query?: TeamScopedPagination, options?: RequestOptions): Promise<Paginated<Volume>>;
+    /** Iterate over all volumes across paginated results. */
+    iterate(query?: TeamScopedPagination, options?: RequestOptions): AsyncGenerator<Volume>;
+    /**
+     * Create a new volume.
+     * This SDK accepts only `type: "sandbox"` and defaults to it when omitted.
+     */
+    create(input: CreateVolumeInput, options?: RequestOptions): Promise<Volume>;
+    /** Fetch one volume by id. */
+    get(volumeId: string, options?: RequestOptions): Promise<Volume>;
+    /** Delete a volume by id. */
+    delete(volumeId: string, options?: RequestOptions): Promise<void>;
+}

package/dist/src/resources/volumes.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VolumesResource = void 0;
+const pagination_1 = require("../transport/pagination");
+const enums_1 = require("../enums");
+const constants_1 = require("../constants");
+class VolumesResource {
+    transport;
+    /** @internal Create the volumes resource wrapper. */
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** List your volumes with pagination. */
+    list(query = {}, options) {
+        const params = (0, pagination_1.toPaginationQuery)(query);
+        if (query.teamId) {
+            params.set('teamId', query.teamId);
+        }
+        return this.transport.requestJson({
+            endpoint: '/volumes',
+            method: 'GET',
+            query: params,
+            ...options,
+        });
+    }
+    /** Iterate over all volumes across paginated results. */
+    async *iterate(query = {}, options) {
+        const limit = query.limit ?? constants_1.DEFAULT_PAGE_LIMIT;
+        let page = query.page ?? constants_1.DEFAULT_PAGE;
+        while (true) {
+            const paginated = await this.list({ ...query, page, limit }, options);
+            for (const volume of paginated.data) {
+                yield volume;
+            }
+            if (page >= paginated.totalPages || paginated.data.length === 0) {
+                return;
+            }
+            page += 1;
+        }
+    }
+    /**
+     * Create a new volume.
+     * This SDK accepts only `type: "sandbox"` and defaults to it when omitted.
+     */
+    create(input, options) {
+        if (input.type && input.type !== enums_1.VolumeType.Sandbox) {
+            throw new Error('Only volume type "sandbox" is supported by this package.');
+        }
+        if (input.sizeGB < constants_1.MIN_VOLUME_SIZE_GB) {
+            throw new Error(`Volume size must be at least ${constants_1.MIN_VOLUME_SIZE_GB}GB.`);
+        }
+        const body = {
+            ...input,
+            type: enums_1.VolumeType.Sandbox,
+        };
+        return this.transport.requestJson({
+            endpoint: '/volumes',
+            method: 'POST',
+            body,
+            ...options,
+        });
+    }
+    /** Fetch one volume by id. */
+    get(volumeId, options) {
+        return this.transport.requestJson({
+            endpoint: `/volumes/${volumeId}`,
+            method: 'GET',
+            ...options,
+        });
+    }
+    /** Delete a volume by id. */
+    async delete(volumeId, options) {
+        await this.transport.requestJson({
+            endpoint: `/volumes/${volumeId}`,
+            method: 'DELETE',
+            ...options,
+        });
+    }
+}
+exports.VolumesResource = VolumesResource;

package/dist/src/transport/auth.d.ts

@@ -0,0 +1,2 @@
+/** Build the header value used by `x-brimble-key`. */
+export declare function buildApiKeyHeader(apiKey: string): string;

package/dist/src/transport/auth.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApiKeyHeader = buildApiKeyHeader;
+/** Build the header value used by `x-brimble-key`. */
+function buildApiKeyHeader(apiKey) {
+    return apiKey;
+}

package/dist/src/transport/http.d.ts

@@ -0,0 +1,73 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type RetryOptions = {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    retryStatuses?: number[];
+    retryMethods?: HttpMethod[];
+};
+export type RequestOptions = {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    idempotencyKey?: string;
+    retry?: RetryOptions | false;
+};
+export type JsonRequestArgs = RequestOptions & {
+    endpoint: string;
+    method: HttpMethod;
+    query?: URLSearchParams;
+    body?: JsonValue | undefined;
+    headers?: Record<string, string>;
+};
+export type BinaryRequestArgs = RequestOptions & {
+    endpoint: string;
+    method: HttpMethod;
+    query?: URLSearchParams;
+    body?: ReadableStream<Uint8Array> | Buffer | Uint8Array;
+    headers?: Record<string, string>;
+};
+export type HttpTransportConfig = {
+    baseUrl: string;
+    apiKey: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    retry?: RetryOptions;
+};
+export declare class HttpTransport {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    private readonly retry;
+    /** Create a transport used by all SDK resources. */
+    constructor(config: HttpTransportConfig);
+    /**
+     * Send a JSON request and return the unwrapped `data` payload.
+     * If the endpoint returns 204, this resolves to `undefined`.
+     */
+    requestJson<T>(args: JsonRequestArgs): Promise<T | undefined>;
+    /**
+     * Send a binary upload request (for file writes).
+     * Returns when the API acknowledges success.
+     */
+    requestBinary(args: BinaryRequestArgs): Promise<void>;
+    /**
+     * Send a JSON request and return the raw response stream.
+     * Used for endpoints that stream SSE frames (`text/event-stream`).
+     */
+    requestJsonStream(args: JsonRequestArgs): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Request a binary response stream (for file downloads).
+     * Throws if the API returns an error status.
+     */
+    requestStream(args: RequestOptions & {
+        endpoint: string;
+        method: HttpMethod;
+        query?: URLSearchParams;
+    }): Promise<ReadableStream<Uint8Array>>;
+    private executeRequest;
+    private toApiError;
+}