@blaxel/core 0.3.13 → 0.3.18-dev.283

package/dist/cjs/types/client/types.gen.d.ts

@@ -3494,6 +3494,7 @@ export type SsoDomainSpecWritable = {
  * Lightweight virtual machine for secure AI code execution. Sandboxes resume from standby in under 25ms and automatically scale to zero after inactivity, preserving memory state including running processes and filesystem.
  */
 export type Sandbox = {
+    archive?: SandboxArchive;
     /**
      * Infrastructure failures recorded on the sandbox, oldest first (read-only, managed by the system)
      */
@@ -3523,6 +3524,7 @@ export type Sandbox = {
  * Lightweight virtual machine for secure AI code execution. Sandboxes resume from standby in under 25ms and automatically scale to zero after inactivity, preserving memory state including running processes and filesystem.
  */
 export type SandboxWritable = {
+    archive?: SandboxArchiveWritable;
     events?: CoreEventsWritable;
     metadata: MetadataWritable;
     spec: SandboxSpec;
@@ -3532,6 +3534,72 @@ export type SandboxWritable = {
     state?: 'RUNNING' | 'STANDBY';
     status?: Status;
 };
+/**
+ * State of the filesystem archive of a sandbox. An archive holds the writable filesystem changes and the process configurations of the sandbox, not its memory, so restoring it produces a sandbox with the same disk state and freshly started processes.
+ */
+export type SandboxArchive = {
+    /**
+     * When the archive was created (read-only)
+     */
+    readonly createdAt?: string;
+    /**
+     * Infrastructure generation the archive was taken from (read-only)
+     */
+    readonly generation?: string;
+    /**
+     * Storage key of the archive (read-only)
+     */
+    readonly key?: string;
+    restore?: SandboxArchiveRestore;
+    /**
+     * When the restore of the archive started, while the sandbox is being unarchived (read-only)
+     */
+    readonly restoreStartedAt?: string;
+    /**
+     * Size of the archive in bytes (read-only)
+     */
+    readonly size?: number;
+    /**
+     * When the archive was started, while the filesystem of the sandbox is still being uploaded (read-only)
+     */
+    readonly startedAt?: string;
+};
+/**
+ * State of the filesystem archive of a sandbox. An archive holds the writable filesystem changes and the process configurations of the sandbox, not its memory, so restoring it produces a sandbox with the same disk state and freshly started processes.
+ */
+export type SandboxArchiveWritable = {
+    restore?: SandboxArchiveRestoreWritable;
+};
+/**
+ * Progress of the restore of a sandbox archive. A restore writes the archived filesystem over the image the sandbox booted from, which takes as long as the archive is big; the sandbox answers and its terminal is reachable throughout, but nothing may write to its filesystem until the restore is done.
+ */
+export type SandboxArchiveRestore = {
+    /**
+     * Number of files restored so far (read-only)
+     */
+    readonly files?: number;
+    /**
+     * Bytes of the archive restored so far (read-only)
+     */
+    readonly restoredBytes?: number;
+    /**
+     * Phase of the restore (read-only)
+     */
+    state?: 'downloading' | 'extracting' | 'relaunching' | 'succeeded' | 'failed';
+    /**
+     * Total size of the archive being restored in bytes, absent when the store did not announce it (read-only)
+     */
+    readonly totalBytes?: number;
+};
+/**
+ * Progress of the restore of a sandbox archive. A restore writes the archived filesystem over the image the sandbox booted from, which takes as long as the archive is big; the sandbox answers and its terminal is reachable throughout, but nothing may write to its filesystem until the restore is done.
+ */
+export type SandboxArchiveRestoreWritable = {
+    /**
+     * Phase of the restore (read-only)
+     */
+    state?: 'downloading' | 'extracting' | 'relaunching' | 'succeeded' | 'failed';
+};
 /**
  * Pre-configured sandbox template available in the Sandbox Hub for quick deployment with predefined tools and configurations
  */
@@ -3759,6 +3827,19 @@ export type SandboxNetwork = {
      */
     subnet?: string;
 };
+/**
+ * Result of restoring a sandbox to one of its snapshots. The sandbox keeps its name and URLs; everything it held since the snapshot was taken is gone.
+ */
+export type SandboxRestoreResponse = {
+    /**
+     * Name of the restored sandbox
+     */
+    name: string;
+    /**
+     * Snapshot the sandbox was restored from
+     */
+    snapshotId: string;
+};
 /**
  * Runtime configuration defining how the sandbox VM is provisioned and its resource limits
  */
@@ -3812,6 +3893,10 @@ export type SandboxScheduleEntry = {
      * Maximum number of execution records kept for this schedule. Once reached, recording a new execution deletes the oldest. Defaults to 100.
      */
     maxExecutions?: number;
+    /**
+     * Name of the sandbox this schedule belongs to.
+     */
+    readonly sandbox?: string;
     /**
      * Type of schedule timing. 'cron' for recurring (5-field expression), 'at' for a specific RFC 3339 datetime, 'sleep' for a duration from now (resolved to 'at' on creation).
      */
@@ -3864,7 +3949,7 @@ export type SandboxScheduleEntryListWritable = {
     meta?: PaginationMeta;
 };
 /**
- * One recorded execution of a sandbox schedule. statusCode is the HTTP status from submitting the command to the sandbox (the scheduler does not wait for the command to finish). Stored in the dedicated scheduleexecutions table.
+ * One recorded execution of a sandbox schedule. status and statusCode describe whether the scheduler's process submission was accepted; the scheduler does not wait for the process to finish. Stored in the dedicated scheduleexecutions table.
  */
 export type SandboxScheduleExecution = {
     /**
@@ -3887,10 +3972,18 @@ export type SandboxScheduleExecution = {
      * Name of the process started in the sandbox for this execution, used to look up its logs.
      */
     processName?: string;
+    /**
+     * Name of the sandbox this execution belongs to.
+     */
+    readonly sandbox?: string;
     /**
      * Id of the schedule this execution belongs to.
      */
     scheduleId?: string;
+    /**
+     * Whether submitting the process request was accepted. This is not the process completion status.
+     */
+    status?: 'succeeded' | 'failed';
     /**
      * HTTP status code returned when the scheduled command was submitted to the sandbox (0 if the sandbox could not be reached). 2xx/3xx means the command was accepted.
      */
@@ -3901,7 +3994,7 @@ export type SandboxScheduleExecution = {
     timeout?: number;
 };
 /**
- * One recorded execution of a sandbox schedule. statusCode is the HTTP status from submitting the command to the sandbox (the scheduler does not wait for the command to finish). Stored in the dedicated scheduleexecutions table.
+ * One recorded execution of a sandbox schedule. status and statusCode describe whether the scheduler's process submission was accepted; the scheduler does not wait for the process to finish. Stored in the dedicated scheduleexecutions table.
  */
 export type SandboxScheduleExecutionWritable = {
     /**
@@ -3924,6 +4017,10 @@ export type SandboxScheduleExecutionWritable = {
      * Id of the schedule this execution belongs to.
      */
     scheduleId?: string;
+    /**
+     * Whether submitting the process request was accepted. This is not the process completion status.
+     */
+    status?: 'succeeded' | 'failed';
     /**
      * HTTP status code returned when the scheduled command was submitted to the sandbox (0 if the sandbox could not be reached). 2xx/3xx means the command was accepted.
      */
@@ -3953,6 +4050,19 @@ export type SandboxScheduleExecutionListWritable = {
     data?: Array<SandboxScheduleExecutionWritable>;
     meta?: PaginationMeta;
 };
+/**
+ * Schedule execution counts grouped by submission acceptance status.
+ */
+export type SandboxScheduleExecutionStatusMetrics = {
+    /**
+     * Number of process submissions that were not accepted.
+     */
+    failed?: number;
+    /**
+     * Number of process submissions accepted by the sandbox.
+     */
+    succeeded?: number;
+};
 /**
  * Process execution configuration for a scheduled sandbox task
  */
@@ -3984,6 +4094,32 @@ export type SandboxScheduleInput = {
      */
     workingDir?: string;
 };
+/**
+ * Workspace sandbox scheduling metrics for a UTC minute window. since is inclusive and until is exclusive.
+ */
+export type SandboxScheduleMetrics = {
+    /**
+     * Number of schedule execution submissions in the selected window.
+     */
+    executions?: number;
+    executionsByStatus?: SandboxScheduleExecutionStatusMetrics;
+    /**
+     * Number of active sandboxes in the workspace.
+     */
+    sandboxes?: number;
+    /**
+     * Number of schedules in the workspace.
+     */
+    schedules?: number;
+    /**
+     * Inclusive beginning of the metrics window, normalized to a UTC minute.
+     */
+    since?: string;
+    /**
+     * Exclusive end of the metrics window, normalized to a UTC minute.
+     */
+    until?: string;
+};
 /**
  * A point-in-time snapshot of a sandbox that can be used for forking into a new sandbox or application.
  */
@@ -4051,7 +4187,7 @@ export type SandboxSpec = {
 /**
  * Deployment status of a resource deployed on Blaxel
  */
-export type Status = 'DELETING' | 'TERMINATED' | 'FAILED' | 'DEACTIVATED' | 'DEACTIVATING' | 'UPLOADING' | 'BUILDING' | 'DEPLOYING' | 'DEPLOYED' | 'BUILT';
+export type Status = 'DELETING' | 'TERMINATED' | 'FAILED' | 'DEACTIVATED' | 'DEACTIVATING' | 'UPLOADING' | 'BUILDING' | 'DEPLOYING' | 'DEPLOYED' | 'BUILT' | 'ARCHIVING' | 'ARCHIVED' | 'UNARCHIVING';
 /**
  * Blaxel template
  */
@@ -7582,6 +7718,47 @@ export type UpdateSandboxResponses = {
     200: Sandbox;
 };
 export type UpdateSandboxResponse = UpdateSandboxResponses[keyof UpdateSandboxResponses];
+export type ArchiveSandboxData = {
+    body?: never;
+    path: {
+        /**
+         * Name of the sandbox to archive
+         */
+        sandboxName: string;
+    };
+    query?: never;
+    url: '/sandboxes/{sandboxName}/archive';
+};
+export type ArchiveSandboxErrors = {
+    /**
+     * Unauthorized - Invalid or missing authentication credentials
+     */
+    401: _Error;
+    /**
+     * Forbidden - Insufficient permissions to archive this sandbox
+     */
+    403: _Error;
+    /**
+     * Not found - Sandbox does not exist
+     */
+    404: _Error;
+    /**
+     * Conflict - The sandbox is already archived or is not running
+     */
+    409: _Error;
+    /**
+     * Internal server error
+     */
+    500: _Error;
+};
+export type ArchiveSandboxError = ArchiveSandboxErrors[keyof ArchiveSandboxErrors];
+export type ArchiveSandboxResponses = {
+    /**
+     * Sandbox archived successfully
+     */
+    200: Sandbox;
+};
+export type ArchiveSandboxResponse = ArchiveSandboxResponses[keyof ArchiveSandboxResponses];
 export type ForkSandboxData = {
     body: SandboxForkRequest;
     path: {
@@ -7819,9 +7996,9 @@ export type ListSandboxScheduleExecutionsData = {
          */
         cursor?: string;
         /**
-         * Sort spec, formatted as `<key>:<direction>`. Allowed values are `createdAt:desc` (default), `createdAt:asc`, `name:asc`, `name:desc`. The cursor fingerprint is bound to the sort, so a cursor opened with one value cannot be reused with another. Only honoured starting on Blaxel-Version 2026-04-28.
+         * Sort by creation time. Defaults to newest first.
          */
-        sort?: 'createdAt:desc' | 'createdAt:asc' | 'name:asc' | 'name:desc';
+        sort?: 'createdAt:desc' | 'createdAt:asc';
         /**
          * Substring search across `metadata.name`, `metadata.displayName` and labels (keys + values). Trimmed and lowercased server-side; queries shorter than 2 characters fall back to the unfiltered listing. Bound into the cursor fingerprint so a cursor opened with one query cannot be reused with another. Only honoured starting on Blaxel-Version 2026-04-28.
          */
@@ -7854,9 +8031,9 @@ export type ListSandboxSchedulesData = {
          */
         cursor?: string;
         /**
-         * Sort spec, formatted as `<key>:<direction>`. Allowed values are `createdAt:desc` (default), `createdAt:asc`, `name:asc`, `name:desc`. The cursor fingerprint is bound to the sort, so a cursor opened with one value cannot be reused with another. Only honoured starting on Blaxel-Version 2026-04-28.
+         * Sort by creation time. Defaults to newest first.
          */
-        sort?: 'createdAt:desc' | 'createdAt:asc' | 'name:asc' | 'name:desc';
+        sort?: 'createdAt:desc' | 'createdAt:asc';
         /**
          * Substring search across `metadata.name`, `metadata.displayName` and labels (keys + values). Trimmed and lowercased server-side; queries shorter than 2 characters fall back to the unfiltered listing. Bound into the cursor fingerprint so a cursor opened with one query cannot be reused with another. Only honoured starting on Blaxel-Version 2026-04-28.
          */
@@ -8046,6 +8223,80 @@ export type DeleteSandboxSnapshotResponses = {
     204: void;
 };
 export type DeleteSandboxSnapshotResponse = DeleteSandboxSnapshotResponses[keyof DeleteSandboxSnapshotResponses];
+export type RestoreSandboxSnapshotData = {
+    body?: never;
+    path: {
+        /**
+         * Name of the sandbox to restore
+         */
+        sandboxName: string;
+        /**
+         * ID of the snapshot to restore the sandbox to
+         */
+        snapshotId: string;
+    };
+    query?: never;
+    url: '/sandboxes/{sandboxName}/snapshots/{snapshotId}/restore';
+};
+export type RestoreSandboxSnapshotErrors = {
+    /**
+     * Not found - Sandbox or snapshot does not exist
+     */
+    404: _Error;
+    /**
+     * Internal server error
+     */
+    500: _Error;
+};
+export type RestoreSandboxSnapshotError = RestoreSandboxSnapshotErrors[keyof RestoreSandboxSnapshotErrors];
+export type RestoreSandboxSnapshotResponses = {
+    /**
+     * Sandbox restored successfully
+     */
+    200: SandboxRestoreResponse;
+};
+export type RestoreSandboxSnapshotResponse = RestoreSandboxSnapshotResponses[keyof RestoreSandboxSnapshotResponses];
+export type UnarchiveSandboxData = {
+    body?: never;
+    path: {
+        /**
+         * Name of the sandbox to unarchive
+         */
+        sandboxName: string;
+    };
+    query?: never;
+    url: '/sandboxes/{sandboxName}/unarchive';
+};
+export type UnarchiveSandboxErrors = {
+    /**
+     * Unauthorized - Invalid or missing authentication credentials
+     */
+    401: _Error;
+    /**
+     * Forbidden - Insufficient permissions to unarchive this sandbox
+     */
+    403: _Error;
+    /**
+     * Not found - Sandbox does not exist
+     */
+    404: _Error;
+    /**
+     * Conflict - The sandbox is not archived
+     */
+    409: _Error;
+    /**
+     * Internal server error
+     */
+    500: _Error;
+};
+export type UnarchiveSandboxError = UnarchiveSandboxErrors[keyof UnarchiveSandboxErrors];
+export type UnarchiveSandboxResponses = {
+    /**
+     * Sandbox recreated successfully
+     */
+    200: Sandbox;
+};
+export type UnarchiveSandboxResponse = UnarchiveSandboxResponses[keyof UnarchiveSandboxResponses];
 export type GetSandboxByExternalIdData = {
     body?: never;
     path: {
@@ -8083,6 +8334,116 @@ export type GetSandboxByExternalIdResponses = {
     200: Sandbox;
 };
 export type GetSandboxByExternalIdResponse = GetSandboxByExternalIdResponses[keyof GetSandboxByExternalIdResponses];
+export type ListScheduleExecutionsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of items per page
+         */
+        limit?: number;
+        /**
+         * Opaque cursor returned by a previous response's meta.nextCursor. Only valid for the same query (workspace + filters); the server rejects cursors bound to a different query or older than 24h. Omit on the first page.
+         */
+        cursor?: string;
+        /**
+         * Sort by creation time. Defaults to newest first.
+         */
+        sort?: 'createdAt:desc' | 'createdAt:asc';
+        /**
+         * Substring search across `metadata.name`, `metadata.displayName` and labels (keys + values). Trimmed and lowercased server-side; queries shorter than 2 characters fall back to the unfiltered listing. Bound into the cursor fingerprint so a cursor opened with one query cannot be reused with another. Only honoured starting on Blaxel-Version 2026-04-28.
+         */
+        q?: string;
+        /**
+         * Filter by process submission acceptance status. Historical rows without status do not match this filter.
+         */
+        status?: 'succeeded' | 'failed';
+        /**
+         * Filter by sandbox name.
+         */
+        sandbox?: string;
+        /**
+         * Filter by schedule id.
+         */
+        schedule?: string;
+        /**
+         * Inclusive beginning of the createdAt window, as RFC 3339.
+         */
+        since?: string;
+        /**
+         * Inclusive end of the createdAt window, as RFC 3339.
+         */
+        until?: string;
+    };
+    url: '/schedule-executions';
+};
+export type ListScheduleExecutionsResponses = {
+    /**
+     * successful operation
+     */
+    200: SandboxScheduleExecutionList;
+};
+export type ListScheduleExecutionsResponse = ListScheduleExecutionsResponses[keyof ListScheduleExecutionsResponses];
+export type ListSchedulesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Number of items per page
+         */
+        limit?: number;
+        /**
+         * Opaque cursor returned by a previous response's meta.nextCursor. Only valid for the same query (workspace + filters); the server rejects cursors bound to a different query or older than 24h. Omit on the first page.
+         */
+        cursor?: string;
+        /**
+         * Sort by creation time. Defaults to newest first.
+         */
+        sort?: 'createdAt:desc' | 'createdAt:asc';
+        /**
+         * Substring search across `metadata.name`, `metadata.displayName` and labels (keys + values). Trimmed and lowercased server-side; queries shorter than 2 characters fall back to the unfiltered listing. Bound into the cursor fingerprint so a cursor opened with one query cannot be reused with another. Only honoured starting on Blaxel-Version 2026-04-28.
+         */
+        q?: string;
+        /**
+         * Filter by sandbox name.
+         */
+        sandbox?: string;
+        /**
+         * Filter schedules by stored timing type. sleep resolves to at before persistence.
+         */
+        type?: 'cron' | 'at';
+    };
+    url: '/schedules';
+};
+export type ListSchedulesResponses = {
+    /**
+     * successful operation
+     */
+    200: SandboxScheduleEntryList;
+};
+export type ListSchedulesResponse = ListSchedulesResponses[keyof ListSchedulesResponses];
+export type GetSandboxScheduleMetricsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Inclusive beginning of the metrics window, as RFC 3339. Normalized down to a UTC minute, must be within the last 7 days, and defaults to 24 hours before until.
+         */
+        since?: string;
+        /**
+         * Exclusive end of the metrics window, as RFC 3339. Normalized down to a UTC minute and defaults to the current minute.
+         */
+        until?: string;
+    };
+    url: '/schedules/metrics';
+};
+export type GetSandboxScheduleMetricsResponses = {
+    /**
+     * successful operation
+     */
+    200: SandboxScheduleMetrics;
+};
+export type GetSandboxScheduleMetricsResponse = GetSandboxScheduleMetricsResponses[keyof GetSandboxScheduleMetricsResponses];
 export type GetWorkspaceServiceAccountsData = {
     body?: never;
     path?: never;

package/dist/cjs/types/common/settings.d.ts

@@ -11,6 +11,15 @@ export type Config = {
     proxy?: string;
     apikey?: string;
     workspace?: string;
+    /**
+     * Product token identifying the integration built on this SDK, appended to
+     * the `User-Agent` so Blaxel can attribute traffic to it. Format
+     * `<name>/<semver>` with a lowercase name, e.g.
+     * `"deepseek-harness-blaxel-sandbox/0.1.2"`. Also settable through
+     * `BL_INTEGRATION` or `settings.integration`. An invalid value is ignored
+     * with a warning.
+     */
+    integration?: string;
     /**
      * Disables the SDK-managed HTTP/2 transport. Defaults to `false` (H2 on);
      * set this to `true` (or `BL_DISABLE_H2=1`) to opt out of H2. Note that H2 is
@@ -104,6 +113,12 @@ declare class Settings {
     get commit(): string;
     get sentryDsn(): string;
     get apiVersion(): string;
+    /**
+     * Product token identifying the integration built on this SDK, or `""`.
+     * Resolved from `config.integration`, then `BL_INTEGRATION`. See `Config.integration`.
+     */
+    get integration(): string;
+    set integration(value: string | undefined);
     get headers(): Record<string, string>;
     get name(): string;
     get type(): string;

package/dist/cjs/types/common/shell.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Quote a string so a POSIX shell reads it as one literal argument.
+ *
+ * The sandbox process API accepts a single command string, which the server
+ * runs as `sh -c <command>`. Any value interpolated into that string is parsed
+ * by the shell, so an unquoted path containing `;`, `|`, `&&`, `$()`, backticks
+ * or `>` would execute as its own command. Single quotes suppress every form of
+ * shell expansion; the only character they cannot contain is a single quote
+ * itself, which is closed, escaped, and reopened.
+ *
+ * This is the TypeScript equivalent of Python's `shlex.quote`.
+ */
+export declare function shellQuote(value: string): string;

package/dist/cjs/types/sandbox/sandbox.d.ts

@@ -1,5 +1,5 @@
 import type http2 from "http2";
-import { type ListSandboxesData, type SandboxForkResponse, type SandboxLifecycle, type Sandbox as SandboxModel, type SandboxSnapshot, type SandboxSnapshots } from "../client/index.js";
+import { type ListSandboxesData, type SandboxForkResponse, type SandboxLifecycle, type Sandbox as SandboxModel, type SandboxRestoreResponse, type SandboxSnapshot, type SandboxSnapshots } from "../client/index.js";
 import { SandboxCodegen } from "./codegen/index.js";
 import { SandboxDrive } from "./drive/index.js";
 import { SandboxFileSystem } from "./filesystem/index.js";
@@ -29,6 +29,15 @@ export type SandboxForkOptions = {
      */
     snapshotId?: string;
 };
+/** How long to wait for an archive, or its restore, to finish. */
+export type SandboxArchiveOptions = {
+    /** Wait for the archive/restore to finish. Defaults to true. */
+    wait?: boolean;
+    /** Give up after this many milliseconds. Defaults to 30 minutes. */
+    maxWait?: number;
+    /** Milliseconds between two reads of the sandbox. Defaults to 2 seconds. */
+    interval?: number;
+};
 export declare class SandboxInstance {
     private sandbox;
     fs: SandboxFileSystem;
@@ -85,6 +94,18 @@ export declare class SandboxInstance {
      * Delete a snapshot of this sandbox by its ID.
      */
     deleteSnapshot(snapshotId: string): Promise<void>;
+    /**
+     * Restore this sandbox to one of its own snapshots. The sandbox keeps its
+     * name, its URLs and its previews: the running instance is torn down and
+     * rebuilt from the snapshot, so everything written since it was taken is
+     * lost unless it was snapshotted too.
+     *
+     * The restore is asked for without waiting on the guest, the same way a fork
+     * is: connections to a sandbox still resuming are retried by the gateway.
+     *
+     * @param snapshotId - ID of the snapshot to restore this sandbox to.
+     */
+    restore(snapshotId: string): Promise<SandboxRestoreResponse>;
     /**
      * Fork this sandbox into a new sandbox or application.
      *
@@ -103,6 +124,40 @@ export declare class SandboxInstance {
         safe?: boolean;
         createIfNotExist?: boolean;
     }): Promise<SandboxInstance>;
+    /**
+     * Archive a sandbox: keep its filesystem, stop the sandbox.
+     *
+     * The filesystem changes made over the image are exported to the archive store
+     * and the sandbox is shut down; memory and running processes are lost, and the
+     * saved processes start again from their configuration when the sandbox is
+     * unarchived. The export runs in the background: this waits until the sandbox
+     * is ARCHIVED, pass `{ wait: false }` to return as soon as it is launched.
+     */
+    static archive(sandboxName: string, options?: SandboxArchiveOptions): Promise<SandboxInstance>;
+    /**
+     * Archive this sandbox: keep its filesystem, stop the sandbox.
+     *
+     * @see SandboxInstance.archive
+     */
+    archive(options?: SandboxArchiveOptions): Promise<this>;
+    /**
+     * Recreate an archived sandbox from its archive.
+     *
+     * The sandbox is started again from its image, and the archived filesystem is
+     * written back over it. The sandbox answers, and its terminal is reachable, while the archived
+     * filesystem is written back over its image. This waits until the restore is
+     * done and the saved processes are running again; pass `{ wait: false }` to
+     * return while the sandbox is still UNARCHIVING.
+     */
+    static unarchive(sandboxName: string, options?: SandboxArchiveOptions): Promise<SandboxInstance>;
+    /**
+     * Recreate this sandbox from its archive.
+     *
+     * @see SandboxInstance.unarchive
+     */
+    unarchive(options?: SandboxArchiveOptions): Promise<this>;
+    private refreshFrom;
+    private static waitForArchiveStatus;
     static get(sandboxName: string): Promise<SandboxInstance>;
     static getByExternalId(externalId: string): Promise<SandboxInstance>;
     /**

package/dist/cjs/types/sandbox/schedule.d.ts

@@ -25,7 +25,7 @@ export declare class SandboxSchedules {
     list(options?: SandboxScheduleListOptions): Promise<import("../common/pagination.js").PaginatedList<SandboxScheduleEntry, {
         limit?: number;
         cursor?: string;
-        sort?: "createdAt:desc" | "createdAt:asc" | "name:asc" | "name:desc";
+        sort?: "createdAt:desc" | "createdAt:asc";
         q?: string;
         type?: "cron" | "at";
     }>>;
@@ -43,7 +43,7 @@ export declare class SandboxSchedules {
     executions(options?: SandboxScheduleExecutionListOptions): Promise<import("../common/pagination.js").PaginatedList<SandboxScheduleExecution, {
         limit?: number;
         cursor?: string;
-        sort?: "createdAt:desc" | "createdAt:asc" | "name:asc" | "name:desc";
+        sort?: "createdAt:desc" | "createdAt:asc";
         q?: string;
     }>>;
 }