tensorlake 0.5.135 → 0.5.136

package/dist/index.d.cts

@@ -67,6 +67,10 @@ interface NativeSandboxProxyClient {
 }
 interface NativeSandboxClient {
     createSandbox(requestJson: string): Promise<TracedJson>;
+    /** Wait-free create (`wait: false`, ADR 0086). */
+    createSandboxNoWait(requestJson: string): Promise<TracedJson>;
+    /** Poll the sandbox until it leaves `pending` or the budget runs out; resolves with the last `SandboxInfo`. */
+    waitForSandbox(sandboxId: string, timeoutSec: number, pollIntervalSec?: number | null): Promise<TracedJson>;
     claimSandbox(poolId: string, requestJson?: string): Promise<TracedJson>;
     copySandbox(sandboxId: string, times: number): Promise<TracedJson>;
     getSandbox(sandboxId: string): Promise<TracedJson>;
@@ -149,6 +153,27 @@ declare enum SandboxStatus {
     /** Terminal status used by blocking create/claim responses. */
     FAILED = "failed"
 }
+/**
+ * Why a pending sandbox is waiting (`pendingReason`). The wire value is a
+ * snake_case string; unknown future reasons arrive as plain strings.
+ */
+declare enum SandboxPendingReason {
+    SCHEDULING = "scheduling",
+    WAITING_FOR_CONTAINER = "waiting_for_container",
+    NO_EXECUTORS_AVAILABLE = "no_executors_available",
+    NO_RESOURCES_AVAILABLE = "no_resources_available",
+    POOL_AT_CAPACITY = "pool_at_capacity",
+    MAX_CAPACITY_REACHED = "max_capacity_reached",
+    NO_EXECUTOR_FOR_SNAPSHOT_LOCATION = "no_executor_for_snapshot_location",
+    /** The autoscaler reported that no fleet can ever place this shape. */
+    UNPLACEABLE = "unplaceable"
+}
+/** `terminationReason` when a `maxPendingSecs` bound expired, or the shape is unplaceable. */
+declare const TERMINATION_REASON_NO_CAPACITY = "no_capacity";
+/** `terminationReason` when a pending sandbox was deleted before it ran. */
+declare const TERMINATION_REASON_CANCELLED = "cancelled";
+/** Whether a sandbox status is one a readiness wait keeps polling through. */
+declare function isSandboxPending(status: SandboxStatus | string): boolean;
 declare enum SnapshotStatus {
     IN_PROGRESS = "in_progress",
     LOCAL_READY = "local_ready",
@@ -298,6 +323,22 @@ interface CreateSandboxOptions {
     name?: string;
     /** File systems to mount on fresh creation or warm-pool claim, each at its own absolute, unique guest mount path. */
     fileSystems?: FileSystemMount[];
+    /**
+     * `false` returns a `PendingSandbox` handle as soon as the sandbox is
+     * durable, without waiting for it to run: `pending.ready()` waits,
+     * `pending.status()` looks, and `Sandbox.connect(pending.sandboxId)`
+     * collects it from any other process. `true` / unset waits as before.
+     */
+    wait?: boolean;
+    /**
+     * Longest the sandbox may wait for capacity before the server fails it with
+     * reason `no_capacity`. `0` fails at once when it cannot be placed; unset
+     * (the default) waits indefinitely. Applies to capacity waits only, not to
+     * image pull or boot. A bound shorter than the fleet's boot time (up to 20
+     * minutes on metal hosts) expires the very demand that made the autoscaler
+     * launch a host; 30 minutes or more is recommended for capacity waits.
+     */
+    maxPendingSecs?: number;
 }
 interface UpdateSandboxOptions {
     /** New name for the sandbox. Naming an ephemeral sandbox enables suspend/resume. */
@@ -313,6 +354,14 @@ interface UpdateSandboxOptions {
      */
     network?: NetworkConfig | null;
 }
+/**
+ * Response from a blocking create or a pool claim.
+ *
+ * The server waits for readiness for at most the request timeout and can
+ * already report `running`; a `pending` answer carries a `pendingReason`.
+ * Use `connect(sandboxId)` to wait for a pending sandbox, or
+ * `create({ wait: false })` for a `PendingSandbox` handle.
+ */
 interface CreateSandboxResponse {
     sandboxId: string;
     status: SandboxStatus;
@@ -323,6 +372,38 @@ interface CreateSandboxResponse {
     name?: string | null;
     terminationReason?: string;
     errorDetails?: unknown;
+    pendingReason?: string;
+}
+/**
+ * The acknowledgement of a `create({ wait: false })`: the wire record of a
+ * sandbox that is durable and starts whenever capacity allows. The
+ * `PendingSandbox` class in `pending-sandbox.ts` wraps it with `ready()` /
+ * `status()`. A server that predates `wait: false` answers the blocking
+ * create's shape instead, so `state` may already be `running`.
+ */
+interface PendingSandboxRecord {
+    sandboxId: string;
+    name?: string;
+    state: SandboxStatus;
+    pendingReason?: string;
+    routingHint?: string;
+    ingressEndpoint?: string;
+    sandboxUrl?: string;
+    reason?: string;
+    terminationReason?: string;
+    errorDetails?: unknown;
+}
+interface ReadyOptions {
+    /** Seconds to wait; defaults to the client requestTimeout. `0` observes the current state once. */
+    timeout?: number;
+    /** Seconds between `GET /sandboxes/{id}` polls. Default: 2. */
+    pollInterval?: number;
+    /**
+     * Delete the sandbox when `timeout` runs out while it is still pending,
+     * then throw `SandboxError` (the pre-ADR-0086 behaviour). Default false:
+     * throw `SandboxPending` and leave the sandbox queued.
+     */
+    cancelOnTimeout?: boolean;
 }
 interface CopySandboxOptions {
     /** Number of running copies to create. Defaults to 1. */
@@ -361,6 +442,8 @@ interface SandboxInfo {
     outcome?: string;
     terminationReason?: string;
     errorDetails?: unknown;
+    /** Why a pending sandbox is waiting, in snake_case. */
+    pendingReason?: string;
     createdAt?: Date;
     terminatedAt?: Date;
     name?: string;
@@ -716,6 +799,14 @@ interface CreateAndConnectOptions extends CreateSandboxOptions {
     requestTimeout?: number;
     /** @deprecated Use requestTimeout. */
     startupTimeout?: number;
+    /**
+     * Delete the sandbox when `requestTimeout` runs out while it is still
+     * pending, then throw `SandboxError` (the pre-ADR-0086 behaviour). Default
+     * false: throw `SandboxPending` and leave the sandbox queued.
+     */
+    cancelOnTimeout?: boolean;
+    /** Seconds between readiness polls. Default: 2. */
+    pollInterval?: number;
 }
 /**
  * Options for `Sandbox.getOrCreate`: everything `create` accepts (used only
@@ -929,17 +1020,36 @@ declare class Sandbox {
     _getLifecycleIdentifier(): string;
     /** @internal Used by SandboxClient.createAndConnect to set ownership. */
     _setOwner(client: SandboxClient): void;
+    /** @internal Used by PendingSandbox.ready for a non-owning handle. */
+    _setLifecycleClient(client: SandboxClient): void;
     /**
      * Create a new sandbox and return a connected, running handle.
      *
      * Covers both fresh sandbox creation and restore-from-snapshot (set
-     * `snapshotId`). Blocks until the sandbox is `Running`.
+     * `snapshotId`). With `wait` unset or `true` it blocks until the sandbox
+     * is `Running`: the create is sent with `wait: false` and the sandbox is
+     * polled every two seconds, with `requestTimeout` as the wait budget.
+     *
+     * With `wait: false` it returns a {@link PendingSandbox} at once:
+     * `pending.ready()` waits for it, `pending.status()` looks at it, and
+     * `Sandbox.connect({ sandboxId: pending.sandboxId })` collects it from any
+     * other process. This is the call for requesting many sandboxes ahead of
+     * capacity. `wait: false` cannot be combined with `poolId`.
+     *
+     * **When the wait runs out the sandbox is not deleted.** A
+     * `SandboxPending` is thrown carrying the sandbox id; the sandbox keeps
+     * its place in the queue and starts whenever capacity arrives. Collect it
+     * later with `Sandbox.connect` or delete it to give up. Pass
+     * `cancelOnTimeout: true` for the previous delete-then-throw behaviour,
+     * or `maxPendingSecs` to let the server fail it after a bound.
      *
      * When `name` is already claimed, the server rejects the create with
      * HTTP 409 (`RemoteAPIError`). To attach to the existing sandbox
      * instead, use {@link Sandbox.getOrCreate}.
      */
-    static create(options?: CreateAndConnectOptions & Partial<SandboxClientOptions>): Promise<Sandbox>;
+    static create<O extends CreateAndConnectOptions & Partial<SandboxClientOptions> = CreateAndConnectOptions & Partial<SandboxClientOptions>>(options?: O): Promise<O extends {
+        wait: false;
+    } ? PendingSandbox : Sandbox>;
     /**
      * Attach to an existing sandbox and return a connected handle.
      *
@@ -1183,6 +1293,60 @@ declare class Sandbox {
     daemonInfo(): Promise<Traced<DaemonInfo>>;
 }
 
+/** @internal How a client binds a handle it issued. */
+interface PendingSandboxBinding {
+    client: SandboxClient;
+    proxyUrl?: string;
+    requestTimeout?: number;
+    requestedName?: string | null;
+    ownsSandbox: boolean;
+    traceId: string;
+}
+/**
+ * A sandbox requested with `wait: false`: the handle returned by
+ * `Sandbox.create({ wait: false })` / `SandboxClient.create({ wait: false })`.
+ *
+ * The sandbox is durable and starts whenever capacity allows. Collect it
+ * with {@link PendingSandbox.ready}, look at it with
+ * {@link PendingSandbox.status}, or from any other process with
+ * `Sandbox.connect({ sandboxId })` (which waits while it is pending) or
+ * `client.list()`. `pendingReason` is `scheduling` at create time; the
+ * capacity reasons appear after the first scheduler pass.
+ */
+declare class PendingSandbox implements PendingSandboxRecord {
+    private readonly binding;
+    readonly sandboxId: string;
+    readonly name?: string;
+    readonly state: SandboxStatus;
+    readonly pendingReason?: string;
+    readonly routingHint?: string;
+    readonly ingressEndpoint?: string;
+    readonly sandboxUrl?: string;
+    readonly reason?: string;
+    readonly terminationReason?: string;
+    readonly errorDetails?: unknown;
+    /** W3C trace id of the create request. */
+    readonly traceId: string;
+    /** @internal */
+    constructor(record: PendingSandboxRecord, binding: PendingSandboxBinding);
+    /** Fetch the sandbox's current state with one `GET`. */
+    status(): Promise<Traced<SandboxInfo>>;
+    /**
+     * Wait for the sandbox to be running and return a connected `Sandbox`.
+     *
+     * Polls `GET /sandboxes/{id}` every `pollInterval` seconds (default 2).
+     * Call it again after a `SandboxPending` to keep waiting.
+     *
+     * @throws {SandboxPending} `timeout` elapsed while the sandbox was still
+     *   pending. It keeps its place in the queue; the error carries
+     *   `sandboxId` and `pendingReason`.
+     * @throws {SandboxError} The sandbox settled somewhere else: `terminated`
+     *   or `failed` (`reason` is the server's, such as `no_capacity` or
+     *   `cancelled`), or `suspended`.
+     */
+    ready(options?: ReadyOptions): Promise<Sandbox>;
+}
+
 /**
  * Client for managing TensorLake sandboxes, pools, and snapshots.
  *
@@ -1226,8 +1390,50 @@ declare class SandboxClient {
     private tracedJson;
     /** Run a native JSON call and reshape it into a plain `T` (no trace id). */
     private plainJson;
-    /** Create a new sandbox. Returns immediately; the sandbox may still be starting. Use `createAndConnect()` for a blocking, ready-to-use handle. */
-    create(options?: CreateSandboxOptions): Promise<Traced<CreateSandboxResponse>>;
+    /**
+     * Create a new sandbox.
+     *
+     * With `wait` unset or `true` the server waits for readiness for at most
+     * the request timeout and answers the blocking create's record (`status`
+     * may already be `running`); this is the wire behaviour unchanged. With
+     * `wait: false` the server answers as soon as the sandbox is durable and
+     * this returns a {@link PendingSandbox} at once: `pending.ready()` waits
+     * for it, `pending.status()` looks at it, and `connect(sandboxId)`
+     * collects it from any other process. Give the sandbox a `name` when a
+     * retry of this call must not create a second one: a repeated name is an
+     * HTTP 409, and `Sandbox.getOrCreate` resolves it. Use
+     * `createAndConnect()` for a blocking, ready-to-use handle.
+     */
+    create<O extends CreateSandboxOptions = CreateSandboxOptions>(options?: O): Promise<O extends {
+        wait: false;
+    } ? PendingSandbox : Traced<CreateSandboxResponse>>;
+    /**
+     * @internal Send the create with `wait: false` and return the pending
+     * handle, bound to this client so `ready()` / `status()` work.
+     */
+    requestPending(options: CreateSandboxOptions | undefined, binding: {
+        proxyUrl?: string;
+        requestTimeout?: number;
+        ownsSandbox: boolean;
+    }): Promise<PendingSandbox>;
+    /** @internal Implementation of `PendingSandbox.ready`. */
+    _ready(sandboxId: string, binding: PendingSandboxBinding, options?: ReadyOptions): Promise<Sandbox>;
+    /**
+     * Poll `get` every `pollInterval` seconds until the sandbox leaves
+     * `pending` or `timeout` elapses, resolving with the last observation.
+     * Never rejects for a timeout and never deletes.
+     */
+    private waitForSandbox;
+    /** Turn the last observed sandbox state into a handle or an error. */
+    private settleWait;
+    /**
+     * Routing for a lazy `connect` handle. A sandbox that is still pending is
+     * waited on here rather than failing: readiness is a property of the
+     * sandbox, not of the create call that requested it.
+     */
+    private resolveRoutingInfo;
+    /** @internal Build the create wire body; shared by `create` and `createAndConnect`. */
+    static buildCreateRequestBody(options?: CreateSandboxOptions): Record<string, unknown>;
     /** Get current state and metadata for a sandbox by ID. */
     get(sandboxId: string): Promise<Traced<SandboxInfo>>;
     /** List all sandboxes in the namespace. */
@@ -1352,8 +1558,19 @@ declare class SandboxClient {
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * Blocks until the sandbox is ready or `requestTimeout` elapses. The returned
-     * `Sandbox` auto-terminates when `terminate()` is called.
+     * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
+     * polling every `pollInterval` seconds, with `requestTimeout` as the wait
+     * budget, in one call. The returned `Sandbox` auto-terminates when
+     * `terminate()` is called.
+     *
+     * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
+     * is thrown with the sandbox id, and the sandbox keeps its place in the
+     * queue and starts whenever capacity arrives; `connect` with that id to
+     * collect it, or `delete` it to give up. Pass
+     * `cancelOnTimeout: true` for the previous behaviour (delete, then throw
+     * `SandboxError`), or set `maxPendingSecs` to let the server fail it after
+     * a bound. A pool claim (`poolId`) answers from the server-side wait; a
+     * claim that is still starting is then waited on the same way.
      */
     createAndConnect(options?: CreateAndConnectOptions): Promise<Sandbox>;
 }
@@ -2040,9 +2257,42 @@ declare function sandboxUrlFromIngressEndpoint(ingressEndpoint: string, sandboxI
 declare class SandboxException extends Error {
     constructor(message: string);
 }
-/** General sandbox operation error. */
+/**
+ * General sandbox operation error.
+ *
+ * `reason` carries the server's reason when the error describes a sandbox
+ * that failed or terminated: `no_capacity` when a `maxPendingSecs` bound
+ * expired, `cancelled` when a pending sandbox was deleted, or a startup
+ * reason such as `ConfigurationError`. It is undefined for errors that are
+ * not about a sandbox's fate.
+ */
 declare class SandboxError extends SandboxException {
-    constructor(message: string);
+    readonly reason?: string;
+    readonly sandboxId?: string;
+    constructor(message: string, options?: {
+        reason?: string;
+        sandboxId?: string;
+    });
+}
+/**
+ * The wait budget ran out while the sandbox was still queued.
+ *
+ * Thrown by `Sandbox.create`, `createAndConnect`, `PendingSandbox.ready` and
+ * a lazy `connect` when their timeout elapses before the sandbox is running.
+ * **The sandbox is not deleted**: it keeps its place in the queue and starts
+ * whenever capacity arrives. Call `ready()` again to keep waiting,
+ * `Sandbox.connect` from any other process, or `delete` it to give up.
+ * `pendingReason` is the last reason the scheduler recorded (`scheduling`,
+ * `no_resources_available`, `pool_at_capacity`, ...).
+ */
+declare class SandboxPending extends SandboxError {
+    readonly sandboxId: string;
+    readonly pendingReason?: string;
+    readonly timeout?: number;
+    constructor(sandboxId: string, options?: {
+        pendingReason?: string;
+        timeout?: number;
+    });
 }
 /**
  * Raised when the client cannot complete a request against the API server.
@@ -2099,4 +2349,4 @@ declare class RequestExecutionError extends Error {
     constructor(message: string, functionName?: string);
 }
 
-export { ApplicationBuildContext, ApplicationBuildResponse, ApplicationManifest, ApplicationSummary, type ArchivedSandboxInfo, type AttachFileSystemOptions, BinaryPayload, type Branch, BuildInfo, BuildLogEntry, type CheckpointOptions, type CheckpointType, type ClaimSandboxOptions, CliNotFoundError, CloudClient, CloudClientOptions, type CommandResult, type CommitJobError, type CommitJobReadBack, type CommitJobStatus, type ConflictPath, type ConflictTerm, type ConnectDesktopOptions, type ConnectOptions, type ContainerResourcesInfo, ContainerState, type CopiedSandboxResponse, type CopySandboxOptions, type CopySandboxResponse, type CreateAndConnectOptions, CreateApplicationBuildRequest, type CreatePoolOptions, type CreatePtyOptions, type CreatePtySessionOptions, type CreateSandboxOptions, type CreateSandboxPoolResponse, type CreateSandboxResponse, type CreateSnapshotResponse, type CreateTunnelOptions, type DaemonInfo, Desktop, type DesktopDoubleClickOptions, type DesktopPointerOptions, type DirectoryEntry, type FileEntry, FileNotFoundInFilesystemError, FileSystem, type FileSystemMount, Filesystem, FilesystemAPIError, FilesystemClient, type FilesystemClientOptions, FilesystemError, type FilesystemFileRead, type FilesystemInfo, FilesystemMount, FilesystemNotFoundError, type FilesystemReadOptions, type FilesystemSnapshot, type FilesystemSnapshotInfo, type FilesystemStatus, type FilesystemVersion, type GPUResources, type GetOrCreateOptions, type GetOrCreateOutcome, type GetSandboxLogsOptions, type GitCredential, type GitRef, type GitRepository, type GpuModel, type GpuRequest, type HealthResponse, type ListArchivedSandboxesOptions, type ListArchivedSandboxesResponse, type ListDirectoryResponse, type ManagedProcessExit, type ManagedProcessHealthStatus, type ManagedProcessInfo, type ManagedProcessStatus, type MergeConflict, type MergeConflictRecord, type MergeEntry, type MergeOptions, type MergeReport, type MergeStats, MountError, type MountStatus, type MouseButton, type NetworkConfig, NewSecret, type Operation, type OperationRef, type OutputEvent, OutputMode, type OutputResponse, type PoolContainerInfo, PoolInUseError, PoolNotFoundError, type ProcessHealthCheck, type ProcessHealthCheckType, type ProcessInfo, ProcessStatus, type ProcessUser, type ProcessUserSpec, Pty, type PtyConnectionOptions, type PtyDataHandler, type PtyExitHandler, type PtySessionInfo, type PushReport, type PushWorktreeOptions, ReadOnlyMountNotSupportedError, RemoteAPIError, RepositoryClient, type RepositoryClientOptions, type RepositoryHandle, type RepositoryInfo, RepositoryMount, type RepositoryMountOptions, type RepositoryMountStatus, type RepositoryUnmountOptions, RequestExecutionError, RequestFailedError, RequestInput, RequestMetadata, RequestNotFinishedError, RequestOutput, type RestartPolicy, type RestartPolicyConfig, type RunOptions, Sandbox, SandboxClient, type SandboxClientOptions, SandboxConnectionError, SandboxError, SandboxException, type SandboxInfo, type SandboxLogLevel, type SandboxLogSignal, type SandboxLogsResponse, SandboxNotFoundError, type SandboxOptions, type SandboxPoolInfo, type SandboxPortAccess, type SandboxProcessLogFilter, type SandboxProcessLogFiltersResponse, SandboxStatus, SandboxTemplate, Secret, SecretsList, type SendSignalResponse, type SnapshotAndWaitOptions, type SnapshotInfo, type SnapshotOptions, SnapshotStatus, type SnapshotType, type SnapshotWaitCondition, StartImageBuildRequest, type StartProcessOptions, StdinMode, type SuspendResumeOptions, TcpTunnel, type TunnelAddress, type UpdatePoolOptions, UpsertSecretResponse, createFileSystem, deleteFileSystem, listFileSystems, sandboxUrlFromIngressEndpoint };
+export { ApplicationBuildContext, ApplicationBuildResponse, ApplicationManifest, ApplicationSummary, type ArchivedSandboxInfo, type AttachFileSystemOptions, BinaryPayload, type Branch, BuildInfo, BuildLogEntry, type CheckpointOptions, type CheckpointType, type ClaimSandboxOptions, CliNotFoundError, CloudClient, CloudClientOptions, type CommandResult, type CommitJobError, type CommitJobReadBack, type CommitJobStatus, type ConflictPath, type ConflictTerm, type ConnectDesktopOptions, type ConnectOptions, type ContainerResourcesInfo, ContainerState, type CopiedSandboxResponse, type CopySandboxOptions, type CopySandboxResponse, type CreateAndConnectOptions, CreateApplicationBuildRequest, type CreatePoolOptions, type CreatePtyOptions, type CreatePtySessionOptions, type CreateSandboxOptions, type CreateSandboxPoolResponse, type CreateSandboxResponse, type CreateSnapshotResponse, type CreateTunnelOptions, type DaemonInfo, Desktop, type DesktopDoubleClickOptions, type DesktopPointerOptions, type DirectoryEntry, type FileEntry, FileNotFoundInFilesystemError, FileSystem, type FileSystemMount, Filesystem, FilesystemAPIError, FilesystemClient, type FilesystemClientOptions, FilesystemError, type FilesystemFileRead, type FilesystemInfo, FilesystemMount, FilesystemNotFoundError, type FilesystemReadOptions, type FilesystemSnapshot, type FilesystemSnapshotInfo, type FilesystemStatus, type FilesystemVersion, type GPUResources, type GetOrCreateOptions, type GetOrCreateOutcome, type GetSandboxLogsOptions, type GitCredential, type GitRef, type GitRepository, type GpuModel, type GpuRequest, type HealthResponse, type ListArchivedSandboxesOptions, type ListArchivedSandboxesResponse, type ListDirectoryResponse, type ManagedProcessExit, type ManagedProcessHealthStatus, type ManagedProcessInfo, type ManagedProcessStatus, type MergeConflict, type MergeConflictRecord, type MergeEntry, type MergeOptions, type MergeReport, type MergeStats, MountError, type MountStatus, type MouseButton, type NetworkConfig, NewSecret, type Operation, type OperationRef, type OutputEvent, OutputMode, type OutputResponse, PendingSandbox, type PendingSandboxRecord, type PoolContainerInfo, PoolInUseError, PoolNotFoundError, type ProcessHealthCheck, type ProcessHealthCheckType, type ProcessInfo, ProcessStatus, type ProcessUser, type ProcessUserSpec, Pty, type PtyConnectionOptions, type PtyDataHandler, type PtyExitHandler, type PtySessionInfo, type PushReport, type PushWorktreeOptions, ReadOnlyMountNotSupportedError, type ReadyOptions, RemoteAPIError, RepositoryClient, type RepositoryClientOptions, type RepositoryHandle, type RepositoryInfo, RepositoryMount, type RepositoryMountOptions, type RepositoryMountStatus, type RepositoryUnmountOptions, RequestExecutionError, RequestFailedError, RequestInput, RequestMetadata, RequestNotFinishedError, RequestOutput, type RestartPolicy, type RestartPolicyConfig, type RunOptions, Sandbox, SandboxClient, type SandboxClientOptions, SandboxConnectionError, SandboxError, SandboxException, type SandboxInfo, type SandboxLogLevel, type SandboxLogSignal, type SandboxLogsResponse, SandboxNotFoundError, type SandboxOptions, SandboxPending, SandboxPendingReason, type SandboxPoolInfo, type SandboxPortAccess, type SandboxProcessLogFilter, type SandboxProcessLogFiltersResponse, SandboxStatus, SandboxTemplate, Secret, SecretsList, type SendSignalResponse, type SnapshotAndWaitOptions, type SnapshotInfo, type SnapshotOptions, SnapshotStatus, type SnapshotType, type SnapshotWaitCondition, StartImageBuildRequest, type StartProcessOptions, StdinMode, type SuspendResumeOptions, TERMINATION_REASON_CANCELLED, TERMINATION_REASON_NO_CAPACITY, TcpTunnel, type TunnelAddress, type UpdatePoolOptions, UpsertSecretResponse, createFileSystem, deleteFileSystem, isSandboxPending, listFileSystems, sandboxUrlFromIngressEndpoint };