plato-sandbox-sdk 1.1.1

package/dist/core/fetcher/HttpResponsePromise.d.ts

@@ -0,0 +1,59 @@
+import type { WithRawResponse } from "./RawResponse.js";
+/**
+ * A promise that returns the parsed response and lets you retrieve the raw response too.
+ */
+export declare class HttpResponsePromise<T> extends Promise<T> {
+    private innerPromise;
+    private unwrappedPromise;
+    private constructor();
+    /**
+     * Creates an `HttpResponsePromise` from a function that returns a promise.
+     *
+     * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+     * @param args - Arguments to pass to the function.
+     * @returns An `HttpResponsePromise` instance.
+     */
+    static fromFunction<F extends (...args: never[]) => Promise<WithRawResponse<T>>, T>(fn: F, ...args: Parameters<F>): HttpResponsePromise<T>;
+    /**
+     * Creates a function that returns an `HttpResponsePromise` from a function that returns a promise.
+     *
+     * @param fn - A function that returns a promise resolving to a `WithRawResponse` object.
+     * @returns A function that returns an `HttpResponsePromise` instance.
+     */
+    static interceptFunction<F extends (...args: never[]) => Promise<WithRawResponse<T>>, T = Awaited<ReturnType<F>>["data"]>(fn: F): (...args: Parameters<F>) => HttpResponsePromise<T>;
+    /**
+     * Creates an `HttpResponsePromise` from an existing promise.
+     *
+     * @param promise - A promise resolving to a `WithRawResponse` object.
+     * @returns An `HttpResponsePromise` instance.
+     */
+    static fromPromise<T>(promise: Promise<WithRawResponse<T>>): HttpResponsePromise<T>;
+    /**
+     * Creates an `HttpResponsePromise` from an executor function.
+     *
+     * @param executor - A function that takes resolve and reject callbacks to create a promise.
+     * @returns An `HttpResponsePromise` instance.
+     */
+    static fromExecutor<T>(executor: (resolve: (value: WithRawResponse<T>) => void, reject: (reason?: unknown) => void) => void): HttpResponsePromise<T>;
+    /**
+     * Creates an `HttpResponsePromise` from a resolved result.
+     *
+     * @param result - A `WithRawResponse` object to resolve immediately.
+     * @returns An `HttpResponsePromise` instance.
+     */
+    static fromResult<T>(result: WithRawResponse<T>): HttpResponsePromise<T>;
+    private unwrap;
+    /** @inheritdoc */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    /** @inheritdoc */
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    /** @inheritdoc */
+    finally(onfinally?: (() => void) | null): Promise<T>;
+    /**
+     * Retrieves the data and raw response.
+     *
+     * @returns A promise resolving to a `WithRawResponse` object.
+     */
+    withRawResponse(): Promise<WithRawResponse<T>>;
+}
+//# sourceMappingURL=HttpResponsePromise.d.ts.map

package/dist/core/fetcher/RawResponse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The raw response from the fetch call excluding the body.
+ */
+export type RawResponse = Omit<{
+    [K in keyof Response as Response[K] extends Function ? never : K]: Response[K];
+}, "ok" | "body" | "bodyUsed">;
+/**
+ * A raw response indicating that the request was aborted.
+ */
+export declare const abortRawResponse: RawResponse;
+/**
+ * A raw response indicating an unknown error.
+ */
+export declare const unknownRawResponse: RawResponse;
+/**
+ * Converts a `RawResponse` object into a `RawResponse` by extracting its properties,
+ * excluding the `body` and `bodyUsed` fields.
+ *
+ * @param response - The `RawResponse` object to convert.
+ * @returns A `RawResponse` object containing the extracted properties of the input response.
+ */
+export declare function toRawResponse(response: Response): RawResponse;
+/**
+ * Creates a `RawResponse` from a standard `Response` object.
+ */
+export interface WithRawResponse<T> {
+    readonly data: T;
+    readonly rawResponse: RawResponse;
+}
+//# sourceMappingURL=RawResponse.d.ts.map

package/dist/core/fetcher/ResponseWithBody.d.ts

@@ -0,0 +1,5 @@
+export type ResponseWithBody = Response & {
+    body: ReadableStream<Uint8Array>;
+};
+export declare function isResponseWithBody(response: Response): response is ResponseWithBody;
+//# sourceMappingURL=ResponseWithBody.d.ts.map

package/dist/core/fetcher/Supplier.d.ts

@@ -0,0 +1,5 @@
+export type Supplier<T> = T | Promise<T> | (() => T | Promise<T>);
+export declare const Supplier: {
+    get: <T>(supplier: Supplier<T>) => Promise<T>;
+};
+//# sourceMappingURL=Supplier.d.ts.map

package/dist/core/fetcher/createRequestUrl.d.ts

@@ -0,0 +1,2 @@
+export declare function createRequestUrl(baseUrl: string, queryParameters?: Record<string, unknown>): string;
+//# sourceMappingURL=createRequestUrl.d.ts.map

package/dist/core/fetcher/getErrorResponseBody.d.ts

@@ -0,0 +1,2 @@
+export declare function getErrorResponseBody(response: Response): Promise<unknown>;
+//# sourceMappingURL=getErrorResponseBody.d.ts.map

package/dist/core/fetcher/getFetchFn.d.ts

@@ -0,0 +1,2 @@
+export declare function getFetchFn(): Promise<typeof fetch>;
+//# sourceMappingURL=getFetchFn.d.ts.map

package/dist/core/fetcher/getHeader.d.ts

@@ -0,0 +1,2 @@
+export declare function getHeader(headers: Record<string, any>, header: string): string | undefined;
+//# sourceMappingURL=getHeader.d.ts.map

package/dist/core/fetcher/getRequestBody.d.ts

@@ -0,0 +1,8 @@
+export declare namespace GetRequestBody {
+    interface Args {
+        body: unknown;
+        type: "json" | "file" | "bytes" | "other";
+    }
+}
+export declare function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined>;
+//# sourceMappingURL=getRequestBody.d.ts.map

package/dist/core/fetcher/getResponseBody.d.ts

@@ -0,0 +1,2 @@
+export declare function getResponseBody(response: Response, responseType?: string): Promise<unknown>;
+//# sourceMappingURL=getResponseBody.d.ts.map

package/dist/core/fetcher/index.d.ts

@@ -0,0 +1,12 @@
+export type { APIResponse } from "./APIResponse.js";
+export type { BinaryResponse } from "./BinaryResponse.js";
+export type { EndpointMetadata } from "./EndpointMetadata.js";
+export { EndpointSupplier } from "./EndpointSupplier.js";
+export type { Fetcher, FetchFunction } from "./Fetcher.js";
+export { fetcher } from "./Fetcher.js";
+export { getHeader } from "./getHeader.js";
+export { HttpResponsePromise } from "./HttpResponsePromise.js";
+export type { RawResponse, WithRawResponse } from "./RawResponse.js";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.js";
+export { Supplier } from "./Supplier.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/fetcher/makeRequest.d.ts

@@ -0,0 +1,2 @@
+export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half") => Promise<Response>;
+//# sourceMappingURL=makeRequest.d.ts.map

package/dist/core/fetcher/requestWithRetries.d.ts

@@ -0,0 +1,2 @@
+export declare function requestWithRetries(requestFn: () => Promise<Response>, maxRetries?: number): Promise<Response>;
+//# sourceMappingURL=requestWithRetries.d.ts.map

package/dist/core/fetcher/signals.d.ts

@@ -0,0 +1,12 @@
+export declare function getTimeoutSignal(timeoutMs: number): {
+    signal: AbortSignal;
+    abortId: NodeJS.Timeout;
+};
+/**
+ * Returns an abort signal that is getting aborted when
+ * at least one of the specified abort signals is aborted.
+ *
+ * Requires at least node.js 18.
+ */
+export declare function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal;
+//# sourceMappingURL=signals.d.ts.map

package/dist/core/headers.d.ts

@@ -0,0 +1,3 @@
+export declare function mergeHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, string | THeaderValue>;
+export declare function mergeOnlyDefinedHeaders<THeaderValue>(...headersArray: (Record<string, THeaderValue> | null | undefined)[]): Record<string, THeaderValue>;
+//# sourceMappingURL=headers.d.ts.map

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./fetcher/index.js";
+export * from "./runtime/index.js";
+export * from "./stream/index.js";
+export * as url from "./url/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/json.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export declare const toJson: (value: unknown, replacer?: (this: unknown, key: string, value: unknown) => unknown, space?: string | number) => string;
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export declare function fromJson<T = unknown>(text: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): T;
+//# sourceMappingURL=json.d.ts.map

package/dist/core/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { RUNTIME } from "./runtime.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/runtime/runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A constant that indicates which environment and version the SDK is running in.
+ */
+export declare const RUNTIME: Runtime;
+export interface Runtime {
+    type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd" | "edge-runtime";
+    version?: string;
+    parsedVersion?: number;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/core/stream/Stream.d.ts

@@ -0,0 +1,48 @@
+export declare namespace Stream {
+    interface Args {
+        /**
+         * The HTTP response stream to read from.
+         */
+        stream: ReadableStream;
+        /**
+         * The event shape to use for parsing the stream data.
+         */
+        eventShape: JsonEvent | SseEvent;
+        /**
+         * An abort signal to stop the stream.
+         */
+        signal?: AbortSignal;
+    }
+    interface JsonEvent {
+        type: "json";
+        messageTerminator: string;
+    }
+    interface SseEvent {
+        type: "sse";
+        streamTerminator?: string;
+    }
+}
+export declare class Stream<T> implements AsyncIterable<T> {
+    private stream;
+    private parse;
+    /**
+     * The prefix to use for each message. For example,
+     * for SSE, the prefix is "data: ".
+     */
+    private prefix;
+    private messageTerminator;
+    private streamTerminator;
+    private controller;
+    private decoder;
+    constructor({ stream, parse, eventShape, signal }: Stream.Args & {
+        parse: (val: unknown) => Promise<T>;
+    });
+    private iterMessages;
+    [Symbol.asyncIterator](): AsyncIterator<T, void, unknown>;
+    private decodeChunk;
+}
+/**
+ * Browser polyfill for ReadableStream
+ */
+export declare function readableStreamAsyncIterable<T>(stream: any): AsyncIterableIterator<T>;
+//# sourceMappingURL=Stream.d.ts.map

package/dist/core/stream/index.d.ts

@@ -0,0 +1,2 @@
+export { Stream } from "./Stream.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/url/encodePathParam.d.ts

@@ -0,0 +1,2 @@
+export declare function encodePathParam(param: unknown): string;
+//# sourceMappingURL=encodePathParam.d.ts.map

package/dist/core/url/index.d.ts

@@ -0,0 +1,4 @@
+export { encodePathParam } from "./encodePathParam.js";
+export { join } from "./join.js";
+export { toQueryString } from "./qs.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/url/join.d.ts

@@ -0,0 +1,2 @@
+export declare function join(base: string, ...segments: string[]): string;
+//# sourceMappingURL=join.d.ts.map

package/dist/core/url/qs.d.ts

@@ -0,0 +1,7 @@
+interface QueryStringOptions {
+    arrayFormat?: "indices" | "repeat";
+    encode?: boolean;
+}
+export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;
+export {};
+//# sourceMappingURL=qs.d.ts.map

package/dist/errors/ApiError.d.ts

@@ -0,0 +1,13 @@
+import type * as core from "../core/index.js";
+export declare class ApiError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    readonly rawResponse?: core.RawResponse;
+    constructor({ message, statusCode, body, rawResponse, }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+        rawResponse?: core.RawResponse;
+    });
+}
+//# sourceMappingURL=ApiError.d.ts.map

package/dist/errors/ApiTimeoutError.d.ts

@@ -0,0 +1,4 @@
+export declare class ApiTimeoutError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=ApiTimeoutError.d.ts.map

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { ApiError } from "./ApiError.js";
+export { ApiTimeoutError } from "./ApiTimeoutError.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/helpers/SandboxHelpers.d.ts

@@ -0,0 +1,127 @@
+/**
+ * High-level helper functions for sandbox operations.
+ *
+ * This file is NOT generated by Fern and provides convenient wrappers
+ * around the generated API client with built-in operation monitoring.
+ *
+ * Based on the Go implementation in sdk/services/sandbox.go
+ */
+import type { ApiClient } from "../Client.js";
+import type * as Api from "../api/index.js";
+import { SandboxMonitor, type MonitorOptions } from "./SandboxMonitor.js";
+export interface CreateSandboxOptions extends MonitorOptions {
+    /**
+     * Whether to wait for the sandbox to be ready before returning.
+     * If true, monitors the operation until completion.
+     * Default: true
+     */
+    wait?: boolean;
+}
+export interface SetupSandboxOptions extends MonitorOptions {
+    /**
+     * Whether to wait for setup to complete before returning.
+     * If true, monitors the operation until completion.
+     * Default: true
+     */
+    wait?: boolean;
+}
+/**
+ * High-level helpers for sandbox operations that combine API calls
+ * with operation monitoring.
+ */
+export declare class SandboxHelpers {
+    private readonly client;
+    private monitor;
+    constructor(client: ApiClient);
+    /**
+     * Create a sandbox and optionally wait for it to be ready.
+     *
+     * This is a convenience wrapper that:
+     * 1. Calls createSandbox API
+     * 2. If wait=true (default), monitors the operation until completion
+     * 3. Returns the sandbox info
+     *
+     * @param request - Sandbox creation request
+     * @param options - Creation and monitoring options
+     * @returns Sandbox information
+     *
+     * @example
+     * ```typescript
+     * const helpers = new SandboxHelpers(client);
+     *
+     * // Create and wait for ready (default)
+     * const sandbox = await helpers.createSandbox({
+     *   dataset: "base",
+     *   plato_dataset_config: config
+     * }, {
+     *   onProgress: (msg) => console.log(msg)
+     * });
+     *
+     * // Create without waiting
+     * const sandbox = await helpers.createSandbox({
+     *   dataset: "base",
+     *   plato_dataset_config: config
+     * }, { wait: false });
+     * ```
+     */
+    createSandbox(request: Api.CreateSandboxRequest, options?: CreateSandboxOptions): Promise<Api.CreateSandboxResponse>;
+    /**
+     * Setup a sandbox and optionally wait for completion.
+     *
+     * This is a convenience wrapper that:
+     * 1. Calls setupSandbox API
+     * 2. If wait=true (default), monitors the operation until completion
+     * 3. Returns the correlation ID
+     *
+     * @param jobId - Job ID of the sandbox
+     * @param request - Setup request with dataset config and optional SSH key
+     * @param options - Setup and monitoring options
+     * @returns Setup response with correlation ID
+     *
+     * @example
+     * ```typescript
+     * const helpers = new SandboxHelpers(client);
+     *
+     * await helpers.setupSandbox("job_123", {
+     *   dataset: "base",
+     *   plato_dataset_config: config,
+     *   ssh_public_key: publicKey
+     * }, {
+     *   onProgress: (msg) => console.log(msg)
+     * });
+     * ```
+     */
+    setupSandbox(jobId: string, request: Api.SetupSandboxRequest, options?: SetupSandboxOptions): Promise<Api.SetupSandboxResponse>;
+    /**
+     * Create a snapshot and optionally wait for completion.
+     *
+     * @param publicId - Public ID of the sandbox
+     * @param request - Snapshot request
+     * @param options - Monitoring options
+     * @returns Snapshot response
+     */
+    createSnapshot(publicId: string, request: Api.CreateSnapshotRequest, options?: MonitorOptions): Promise<Api.CreateSnapshotResponse>;
+    /**
+     * Start a Plato worker and optionally wait for completion.
+     *
+     * @param publicId - Public ID of the sandbox
+     * @param request - Worker start request
+     * @param options - Monitoring options
+     * @returns Worker start response
+     */
+    startWorker(publicId: string, request: Api.StartWorkerRequest, options?: MonitorOptions): Promise<Api.StartWorkerResponse>;
+    /**
+     * Setup root access and optionally wait for completion.
+     *
+     * @param publicId - Public ID of the sandbox
+     * @param request - Root access setup request
+     * @param options - Monitoring options
+     * @returns Setup response
+     */
+    setupRootAccess(publicId: string, request: Api.SetupRootAccessRequest, options?: MonitorOptions): Promise<Api.SetupRootAccessResponse>;
+    /**
+     * Get the underlying monitor for advanced use cases.
+     */
+    getMonitor(): SandboxMonitor;
+}
+//# sourceMappingURL=SandboxHelpers.d.ts.map

package/dist/helpers/SandboxMonitor.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Helper utilities for monitoring sandbox operations.
+ *
+ * This file is NOT generated by Fern and contains custom business logic
+ * for handling SSE streams from the Plato API.
+ *
+ * Based on the Go implementation in sdk/services/sandbox.go
+ */
+import type { ApiClient } from "../Client.js";
+import type { OperationEvent } from "../api/types/OperationEvent.js";
+export interface MonitorOptions {
+    /**
+     * Timeout in milliseconds for the entire operation.
+     * Default: 600000 (10 minutes)
+     */
+    timeoutMs?: number;
+    /**
+     * Callback for progress updates
+     */
+    onProgress?: (message: string) => void;
+    /**
+     * Abort signal to cancel the operation
+     */
+    abortSignal?: AbortSignal;
+}
+export declare class SandboxOperationError extends Error {
+    readonly event?: OperationEvent;
+    constructor(message: string, event?: OperationEvent);
+}
+export declare class SandboxMonitor {
+    private readonly client;
+    constructor(client: ApiClient);
+    /**
+     * Monitor a sandbox operation until completion.
+     *
+     * This implements the business logic from the Go SDK (sandbox.go):
+     * - Waits for terminal events (run_result, ssh_result, error)
+     * - Reports progress via callback
+     * - Throws on failure
+     * - Returns on success
+     *
+     * @param correlationId - Correlation ID from sandbox creation or setup
+     * @param options - Monitoring options
+     * @throws {SandboxOperationError} If the operation fails
+     * @throws {Error} If the stream ends unexpectedly
+     *
+     * @example
+     * ```typescript
+     * const monitor = new SandboxMonitor(client);
+     * const sandbox = await client.createSandbox({ ... });
+     *
+     * // Wait for sandbox to be ready
+     * await monitor.waitForCompletion(sandbox.correlation_id, {
+     *   onProgress: (msg) => console.log('Progress:', msg)
+     * });
+     * ```
+     */
+    waitForCompletion(correlationId: string, options?: MonitorOptions): Promise<void>;
+    /**
+     * Monitor operation and collect all events.
+     * Useful for debugging or detailed progress tracking.
+     *
+     * @param correlationId - Correlation ID from sandbox creation or setup
+     * @param options - Monitoring options
+     * @returns Array of all events received
+     * @throws {SandboxOperationError} If the operation fails
+     */
+    waitForCompletionWithEvents(correlationId: string, options?: MonitorOptions): Promise<OperationEvent[]>;
+    /**
+     * Handle a single operation event and determine if operation should terminate.
+     *
+     * This implements the state machine from sandbox.go MonitorOperation():
+     * - connected: Continue listening
+     * - progress: Report progress, continue listening
+     * - run_result/ssh_result: Terminal event, check success
+     * - error: Terminal event, always failure
+     *
+     * @private
+     */
+    private handleEvent;
+    /**
+     * Combine multiple abort signals into one.
+     * If any signal aborts, the combined signal aborts.
+     *
+     * @private
+     */
+    private combineAbortSignals;
+}
+//# sourceMappingURL=SandboxMonitor.d.ts.map

package/dist/helpers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Custom helpers for the Plato SDK.
+ *
+ * These utilities are NOT generated by Fern and provide high-level
+ * convenience functions built on top of the generated API client.
+ */
+export { SandboxMonitor, SandboxOperationError, type MonitorOptions } from "./SandboxMonitor.js";
+export { SandboxHelpers, type CreateSandboxOptions, type SetupSandboxOptions } from "./SandboxHelpers.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * as Api from "./api/index.js";
+export type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
+export { ApiClient } from "./Client.js";
+export { ApiError, ApiTimeoutError } from "./errors/index.js";
+export * from "./helpers/index.js";
+//# sourceMappingURL=index.d.ts.map

package/errors/ApiError.ts

@@ -0,0 +1,53 @@
+// This file was auto-generated by Fern from our API Definition.
+
+import type * as core from "../core/index.js";
+import { toJson } from "../core/json.js";
+
+export class ApiError extends Error {
+    public readonly statusCode?: number;
+    public readonly body?: unknown;
+    public readonly rawResponse?: core.RawResponse;
+
+    constructor({
+        message,
+        statusCode,
+        body,
+        rawResponse,
+    }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+        rawResponse?: core.RawResponse;
+    }) {
+        super(buildMessage({ message, statusCode, body }));
+        Object.setPrototypeOf(this, ApiError.prototype);
+        this.statusCode = statusCode;
+        this.body = body;
+        this.rawResponse = rawResponse;
+    }
+}
+
+function buildMessage({
+    message,
+    statusCode,
+    body,
+}: {
+    message: string | undefined;
+    statusCode: number | undefined;
+    body: unknown | undefined;
+}): string {
+    const lines: string[] = [];
+    if (message != null) {
+        lines.push(message);
+    }
+
+    if (statusCode != null) {
+        lines.push(`Status code: ${statusCode.toString()}`);
+    }
+
+    if (body != null) {
+        lines.push(`Body: ${toJson(body, undefined, 2)}`);
+    }
+
+    return lines.join("\n");
+}

package/errors/ApiTimeoutError.ts

@@ -0,0 +1,8 @@
+// This file was auto-generated by Fern from our API Definition.
+
+export class ApiTimeoutError extends Error {
+    constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, ApiTimeoutError.prototype);
+    }
+}

package/errors/index.ts

@@ -0,0 +1,2 @@
+export { ApiError } from "./ApiError.js";
+export { ApiTimeoutError } from "./ApiTimeoutError.js";