@boatdev/sdk 1.6.0 → 1.8.0

package/dist/http2-fetch.js

@@ -0,0 +1,239 @@
+"use strict";
+// The SDK's default fetch. On Node it sends every request to an https origin over
+// ONE shared HTTP/2 connection. Node's global fetch speaks HTTP/1.1 only, so N
+// concurrent calls opened N TLS connections: a burst of 200 calls from a laptop
+// made 200 handshakes (measured 2026-10-08), and 250 creates arrived at the API
+// over 8-14 s. Elsewhere (browsers, Deno, Bun, an origin without HTTP/2), and for
+// any body this does not handle, it is the global fetch.
+// Pass `fetchApi` in the Configuration to use your own fetch instead.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFetch = void 0;
+const sessions = new Map();
+const http1Only = new Set();
+const slots = new WeakMap();
+// A server caps the streams open at once on a connection (boat.dev: 250; this uses
+// at most 100). A stream past the cap is refused, so the excess waits here. Requests open
+// or waiting keep the process alive; an idle shared connection does not.
+async function streamSlot(s, signal) {
+    var _a;
+    let st = slots.get(s);
+    if (!st) {
+        st = { active: 0, waiting: [] };
+        slots.set(s, st);
+    }
+    const state = st;
+    const cap = Math.max(1, Math.min(Number((_a = s.remoteSettings) === null || _a === void 0 ? void 0 : _a.maxConcurrentStreams) || 100, 100));
+    // Already aborted: take no stream, never queue (an abort listener added now never fires).
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+        return () => { };
+    if (state.active === 0 && state.waiting.length === 0)
+        s.ref();
+    if (state.active >= cap) {
+        const turn = await new Promise((wake) => {
+            const w = () => wake(true);
+            state.waiting.push(w);
+            // An aborted waiter leaves the queue without a stream; the caller rejects it.
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
+                const i = state.waiting.indexOf(w);
+                if (i !== -1) {
+                    state.waiting.splice(i, 1);
+                    wake(false);
+                }
+            }, { once: true });
+        });
+        if (!turn)
+            return () => { };
+    }
+    state.active++;
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        state.active--;
+        const next = state.waiting.shift();
+        if (next)
+            next();
+        else if (state.active === 0)
+            s.unref();
+    };
+}
+let nodeHttp2;
+function loadNode() {
+    var _a;
+    if (!nodeHttp2) {
+        const versions = (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.versions;
+        const isNode = !!(versions === null || versions === void 0 ? void 0 : versions.node) && !versions.bun && typeof globalThis.Deno === 'undefined';
+        // A variable, not a literal: a browser bundler must not try to resolve it.
+        const h2 = 'node:http2';
+        nodeHttp2 = isNode
+            ? Promise.resolve(`${h2}`).then(s => __importStar(require(s))).catch(() => null)
+            : Promise.resolve(null);
+    }
+    return nodeHttp2;
+}
+function session(origin, http2) {
+    const open = sessions.get(origin);
+    if (open)
+        return open;
+    const pending = new Promise((resolve) => {
+        let s;
+        try {
+            s = http2.connect(origin);
+        }
+        catch (_a) {
+            resolve(null);
+            return;
+        }
+        const drop = () => { if (sessions.get(origin) === pending)
+            sessions.delete(origin); };
+        s.once('connect', () => {
+            // An origin that answered without h2 never gets here: the TLS layer fails the connect.
+            s.unref(); // an idle shared connection must not keep the process alive
+            resolve(s);
+        });
+        // `on`, not `once`: a session can emit more than one error, and an unhandled one kills the process.
+        s.on('error', () => { drop(); resolve(null); });
+        s.once('close', drop);
+        s.once('goaway', drop);
+    });
+    sessions.set(origin, pending);
+    return pending;
+}
+function sendableBody(body) {
+    if (body == null)
+        return null;
+    if (typeof body === 'string')
+        return body;
+    if (body instanceof Uint8Array)
+        return body;
+    if (body instanceof ArrayBuffer)
+        return new Uint8Array(body);
+    if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams)
+        return body.toString();
+    return undefined; // FormData, Blob, streams: the global fetch encodes these
+}
+const HOP_BY_HOP = new Set(['connection', 'host', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'upgrade']);
+async function http2Fetch(input, init = {}) {
+    const url = new URL(typeof input === 'string' ? input : input instanceof URL ? input.href : input.url);
+    const body = sendableBody(init.body);
+    const node = await loadNode();
+    const isRequest = typeof input !== 'string' && !(input instanceof URL);
+    if (!node || isRequest || body === undefined || url.protocol !== 'https:' || http1Only.has(url.origin)) {
+        return fetch(input, init);
+    }
+    const s = await session(url.origin, node);
+    if (!s || s.closed || s.destroyed) {
+        if (!s)
+            http1Only.add(url.origin);
+        return fetch(input, init);
+    }
+    const headers = { ':method': (init.method || 'GET').toUpperCase(), ':path': url.pathname + url.search };
+    new Headers(init.headers).forEach((value, key) => { if (!HOP_BY_HOP.has(key))
+        headers[key] = value; });
+    const signal = init.signal;
+    const aborted = () => { var _a; return (_a = signal.reason) !== null && _a !== void 0 ? _a : new DOMException('This operation was aborted', 'AbortError'); };
+    const release = await streamSlot(s, signal);
+    return new Promise((resolve, reject) => {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            release();
+            reject(aborted());
+            return;
+        }
+        let req;
+        try {
+            req = s.request(headers, { endStream: body === null });
+        }
+        catch (e) {
+            // The connection closed (GOAWAY) while this call waited for a stream.
+            release();
+            reject(e);
+            return;
+        }
+        const onAbort = () => { req.close(); reject(aborted()); };
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+        req.once('close', () => { release(); signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort); });
+        req.on('error', reject); // after the response this errors its body stream; a no-op here
+        req.once('response', (h) => {
+            const status = Number(h[':status']);
+            const out = new Headers();
+            for (const [k, v] of Object.entries(h)) {
+                if (k.startsWith(':') || v === undefined)
+                    continue;
+                for (const one of Array.isArray(v) ? v : [v])
+                    out.append(k, String(one));
+            }
+            const empty = status === 204 || status === 205 || status === 304 || headers[':method'] === 'HEAD';
+            if (empty)
+                req.resume();
+            // Fed from 'data' events, not Readable.toWeb: an HTTP/2 stream the server has
+            // already closed is destroyed with its unread data, and toWeb's backpressure
+            // turned that into "Premature close" on 25 of 250 calls (prod, 2026-10-08).
+            // A slow reader (streamCommand between frames) must not let a fast command
+            // fill memory: past 4 MiB unread the stream pauses until the reader pulls.
+            const bodyStream = empty ? null : new ReadableStream({
+                start(controller) {
+                    req.on('data', (chunk) => {
+                        var _a;
+                        controller.enqueue(new Uint8Array(chunk));
+                        if (((_a = controller.desiredSize) !== null && _a !== void 0 ? _a : 1) <= 0)
+                            req.pause();
+                    });
+                    req.once('end', () => controller.close());
+                    req.once('error', (e) => controller.error(e));
+                    req.once('close', () => {
+                        if (!req.readableEnded) {
+                            try {
+                                controller.error(new Error(`HTTP/2 stream closed before its end (code ${req.rstCode})`));
+                            }
+                            catch (_a) { }
+                        }
+                    });
+                },
+                pull() { if (req.isPaused())
+                    req.resume(); },
+                cancel() { req.close(); },
+            }, { highWaterMark: 4 * 1024 * 1024, size: (chunk) => { var _a; return (_a = chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) !== null && _a !== void 0 ? _a : 0; } });
+            const response = new Response(bodyStream, { status, headers: out });
+            // Response.url is read-only; the generated client never reads it, but keep it right.
+            Object.defineProperty(response, 'url', { value: url.href });
+            resolve(response);
+        });
+        if (body !== null)
+            req.end(body);
+    });
+}
+exports.defaultFetch = http2Fetch;

package/dist/models/Conversation.d.ts

@@ -46,7 +46,7 @@ export interface Conversation {
      */
     running: boolean;
     /**
-     * Harness the most recent prompt ran on (`claude`, `codex`, `pi`, `opencode`, `prime-agent`, `kimi`).
+     * Harness the most recent prompt ran on (`claude`, `codex`, `pi`, `opencode`, `prime-agent`, `kimi`, `mistral`).
      * @type {string}
      * @memberof Conversation
      */

package/dist/models/CreateSandboxRequest.d.ts

@@ -16,7 +16,7 @@
  */
 export interface CreateSandboxRequest {
     /**
-     * Machine size. `small` consumes machine time at half rate and `large` at twice the default rate (see the Billing guide). A fork inherits the source sandbox's type unless the fork request passes its own, and resume and fork can move a sandbox between sizes.
+     * Machine size. `small` consumes machine time at half rate and `large` at twice the default rate (see the Billing guide). `xlarge` needs the $100/month plan or higher; lower plans get a 403 `machine_class_plan_required` on create, resume and fork. A fork inherits the source sandbox's type unless the fork request passes its own, and resume and fork can move a sandbox between sizes.
      * @type {CreateSandboxRequestTypeEnum}
      * @memberof CreateSandboxRequest
      */
@@ -60,7 +60,7 @@ export interface CreateSandboxRequest {
      */
     failFast?: boolean;
     /**
-     * Shell script that runs on the sandbox after it is ready. Ready means "ready to accept the user", not "setup done": the script starts in the background once provisioning completes and never blocks the sandbox becoming usable. It runs as the sandbox user via `bash`, with the sandbox's environment applied, and its output goes to a log file on the sandbox. Observe the outcome as `setupStatus` (pending/running/done/failed) and `setupError` on the sandbox. Rejected with a 400 `invalid_setup_script` error when it is not a string or exceeds 64KB.
+     * Shell script that runs on the sandbox after it is ready. Ready means "ready to accept the user", not "setup done": the script starts in the background once provisioning completes and never blocks the sandbox becoming usable. It runs as the sandbox user (`user`, not root; `sudo` needs no password) via `bash`, with the sandbox's environment applied, and its output goes to a log file on the sandbox. Observe the outcome as `setupStatus` (pending/running/done/failed) and `setupError` on the sandbox. Rejected with a 400 `invalid_setup_script` error when it is not a string or exceeds 64KB.
      * @type {string}
      * @memberof CreateSandboxRequest
      */
@@ -91,6 +91,7 @@ export declare const CreateSandboxRequestTypeEnum: {
     readonly Small: 'small';
     readonly Default: 'default';
     readonly Large: 'large';
+    readonly Xlarge: 'xlarge';
 };
 export type CreateSandboxRequestTypeEnum = typeof CreateSandboxRequestTypeEnum[keyof typeof CreateSandboxRequestTypeEnum];
 /**

package/dist/models/CreateSandboxRequest.js

@@ -25,7 +25,8 @@ exports.CreateSandboxRequestToJSONTyped = CreateSandboxRequestToJSONTyped;
 exports.CreateSandboxRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 };
 /**
  * Check if a given object implements the CreateSandboxRequest interface.

package/dist/models/ForkRequest.d.ts

@@ -42,7 +42,7 @@ export interface ForkRequest {
      */
     noEnv?: boolean;
     /**
-     * Machine size for the fork. Omit to inherit the source sandbox's type. The source sandbox is never modified. Shrinking is rejected with `type_too_small` when the source's data would not fit the smaller disk.
+     * Machine size for the fork. Omit to inherit the source sandbox's type. `xlarge` needs the $100/month plan or higher (403 `machine_class_plan_required`). The source sandbox is never modified. Shrinking is rejected with `type_too_small` when the source's data would not fit the smaller disk.
      * @type {ForkRequestTypeEnum}
      * @memberof ForkRequest
      */
@@ -61,6 +61,7 @@ export declare const ForkRequestTypeEnum: {
     readonly Small: 'small';
     readonly Default: 'default';
     readonly Large: 'large';
+    readonly Xlarge: 'xlarge';
 };
 export type ForkRequestTypeEnum = typeof ForkRequestTypeEnum[keyof typeof ForkRequestTypeEnum];
 /**

package/dist/models/ForkRequest.js

@@ -25,7 +25,8 @@ exports.ForkRequestToJSONTyped = ForkRequestToJSONTyped;
 exports.ForkRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 };
 /**
  * Check if a given object implements the ForkRequest interface.

package/dist/models/PromptRequest.d.ts

@@ -12,7 +12,7 @@
 /**
  * Work item to queue inside an existing sandbox. Provider credentials must already be configured in the Boat dashboard.
  *
- * **Providers (harnesses):** `codex`, `claude-code` (alias `claude`), `pi`, `opencode`, `prime-agent` (alias `prime`), `kimi` (Kimi Code CLI, alias `kimi-code`). Omit `provider` to use the harness the user selected on the Agents dashboard.
+ * **Providers (harnesses):** `codex`, `claude-code` (alias `claude`), `pi`, `opencode`, `prime-agent` (alias `prime`), `kimi` (Kimi Code CLI, alias `kimi-code`), `mistral` (Mistral Vibe). Omit `provider` to use the harness the user selected on the Agents dashboard.
  *
  * **Models & reasoning effort** are harness- and model-specific and change over time. Fetch the live catalog (every provider's models and which reasoning-effort levels each accepts) from `GET /provider-models`. Some models accept no reasoning control. `pi`, `opencode` and `prime-agent` also expose models routed through OpenRouter and llmgateway (ids like `openrouter:anthropic/claude-sonnet-4.5`).
  *
@@ -78,6 +78,7 @@ export declare const PromptRequestProviderEnum: {
     readonly Prime: 'prime';
     readonly Kimi: 'kimi';
     readonly KimiCode: 'kimi-code';
+    readonly Mistral: 'mistral';
 };
 export type PromptRequestProviderEnum = typeof PromptRequestProviderEnum[keyof typeof PromptRequestProviderEnum];
 /**

package/dist/models/PromptRequest.js

@@ -31,7 +31,8 @@ exports.PromptRequestProviderEnum = {
     PrimeAgent: 'prime-agent',
     Prime: 'prime',
     Kimi: 'kimi',
-    KimiCode: 'kimi-code'
+    KimiCode: 'kimi-code',
+    Mistral: 'mistral'
 };
 /**
  * Check if a given object implements the PromptRequest interface.

package/dist/models/Recover200Response.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface Recover200Response
+ */
+export interface Recover200Response {
+    /**
+     *
+     * @type {boolean}
+     * @memberof Recover200Response
+     */
+    ok?: boolean;
+    /**
+     *
+     * @type {string}
+     * @memberof Recover200Response
+     */
+    type?: string;
+    /**
+     *
+     * @type {Recover200ResponseStatusEnum}
+     * @memberof Recover200Response
+     */
+    status?: Recover200ResponseStatusEnum;
+    /**
+     *
+     * @type {string}
+     * @memberof Recover200Response
+     */
+    message?: string;
+}
+/**
+ * @export
+ */
+export declare const Recover200ResponseStatusEnum: {
+    readonly Recovering: 'recovering';
+};
+export type Recover200ResponseStatusEnum = typeof Recover200ResponseStatusEnum[keyof typeof Recover200ResponseStatusEnum];
+/**
+ * Check if a given object implements the Recover200Response interface.
+ */
+export declare function instanceOfRecover200Response(value: object): value is Recover200Response;
+export declare function Recover200ResponseFromJSON(json: any): Recover200Response;
+export declare function Recover200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): Recover200Response;
+export declare function Recover200ResponseToJSON(json: any): Recover200Response;
+export declare function Recover200ResponseToJSONTyped(value?: Recover200Response | null, ignoreDiscriminator?: boolean): any;

package/dist/models/Recover200Response.js

@@ -0,0 +1,61 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Recover200ResponseStatusEnum = void 0;
+exports.instanceOfRecover200Response = instanceOfRecover200Response;
+exports.Recover200ResponseFromJSON = Recover200ResponseFromJSON;
+exports.Recover200ResponseFromJSONTyped = Recover200ResponseFromJSONTyped;
+exports.Recover200ResponseToJSON = Recover200ResponseToJSON;
+exports.Recover200ResponseToJSONTyped = Recover200ResponseToJSONTyped;
+/**
+ * @export
+ */
+exports.Recover200ResponseStatusEnum = {
+    Recovering: 'recovering'
+};
+/**
+ * Check if a given object implements the Recover200Response interface.
+ */
+function instanceOfRecover200Response(value) {
+    return true;
+}
+function Recover200ResponseFromJSON(json) {
+    return Recover200ResponseFromJSONTyped(json, false);
+}
+function Recover200ResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'ok': json['ok'] == null ? undefined : json['ok'],
+        'type': json['type'] == null ? undefined : json['type'],
+        'status': json['status'] == null ? undefined : json['status'],
+        'message': json['message'] == null ? undefined : json['message'],
+    };
+}
+function Recover200ResponseToJSON(json) {
+    return Recover200ResponseToJSONTyped(json, false);
+}
+function Recover200ResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'ok': value['ok'],
+        'type': value['type'],
+        'status': value['status'],
+        'message': value['message'],
+    };
+}

package/dist/models/ResumeRequest.d.ts

@@ -22,7 +22,7 @@ export interface ResumeRequest {
      */
     failFast?: boolean;
     /**
-     * Resume onto a different machine size. Omit to keep the sandbox's current type. A resume already restores onto a fresh machine, so changing size costs nothing extra. Shrinking is rejected with `type_too_small` when the sandbox's data would not fit the smaller disk.
+     * Resume onto a different machine size. Omit to keep the sandbox's current type. `xlarge` needs the $100/month plan or higher (403 `machine_class_plan_required`). A resume already restores onto a fresh machine, so changing size costs nothing extra. Shrinking is rejected with `type_too_small` when the sandbox's data would not fit the smaller disk.
      * @type {ResumeRequestTypeEnum}
      * @memberof ResumeRequest
      */
@@ -61,6 +61,7 @@ export declare const ResumeRequestTypeEnum: {
     readonly Small: 'small';
     readonly Default: 'default';
     readonly Large: 'large';
+    readonly Xlarge: 'xlarge';
 };
 export type ResumeRequestTypeEnum = typeof ResumeRequestTypeEnum[keyof typeof ResumeRequestTypeEnum];
 /**

package/dist/models/ResumeRequest.js

@@ -25,7 +25,8 @@ exports.ResumeRequestToJSONTyped = ResumeRequestToJSONTyped;
 exports.ResumeRequestTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 };
 /**
  * Check if a given object implements the ResumeRequest interface.

package/dist/models/Sandbox.d.ts

@@ -10,6 +10,7 @@
  * Do not edit the class manually.
  */
 import type { SandboxTeam } from './SandboxTeam';
+import type { StopOperation } from './StopOperation';
 /**
  *
  * @export
@@ -58,6 +59,18 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     degradedSince?: Date | null;
+    /**
+     * True once every file of the sandbox's snapshot is on its disk. A resumed or forked sandbox is usable before that: its files keep copying in the background, and its docker volumes move onto the real disk near the end. Its docker containers start earlier; at that point their volume mounts move onto the real disk in place, without a restart. The `sandbox.hydrated` webhook fires at the same moment this turns true. A sandbox that restored nothing is hydrated from the start.
+     * @type {boolean}
+     * @memberof Sandbox
+     */
+    hydrated?: boolean;
+    /**
+     * When the last resume or fork finished copying files in, or null.
+     * @type {Date}
+     * @memberof Sandbox
+     */
+    hydratedAt?: Date | null;
     /**
      * Current machine size: what the sandbox was created with, or the size it was last resumed or forked onto.
      * @type {SandboxTypeEnum}
@@ -77,7 +90,7 @@ export interface Sandbox {
      */
     memoryGB?: number;
     /**
-     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, and 2 for `large`.
+     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, 2 for `large`, and 50/9 (about 5.56) for `xlarge`.
      * @type {number}
      * @memberof Sandbox
      */
@@ -238,6 +251,12 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     environmentVersion?: number | null;
+    /**
+     * The last stop you requested (`POST /sandboxes/{sandboxId}/stop`), or null if you never stopped this sandbox.
+     * @type {StopOperation}
+     * @memberof Sandbox
+     */
+    stop?: StopOperation | null;
 }
 /**
  * @export
@@ -271,6 +290,7 @@ export declare const SandboxTypeEnum: {
     readonly Small: 'small';
     readonly Default: 'default';
     readonly Large: 'large';
+    readonly Xlarge: 'xlarge';
 };
 export type SandboxTypeEnum = typeof SandboxTypeEnum[keyof typeof SandboxTypeEnum];
 /**

package/dist/models/Sandbox.js

@@ -20,6 +20,7 @@ exports.SandboxFromJSONTyped = SandboxFromJSONTyped;
 exports.SandboxToJSON = SandboxToJSON;
 exports.SandboxToJSONTyped = SandboxToJSONTyped;
 const SandboxTeam_1 = require("./SandboxTeam");
+const StopOperation_1 = require("./StopOperation");
 /**
  * @export
  */
@@ -49,7 +50,8 @@ exports.SandboxHealthEnum = {
 exports.SandboxTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 };
 /**
  * @export
@@ -116,6 +118,8 @@ function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'health': json['health'] == null ? undefined : json['health'],
         'healthReason': json['healthReason'] == null ? undefined : json['healthReason'],
         'degradedSince': json['degradedSince'] == null ? undefined : (new Date(json['degradedSince'])),
+        'hydrated': json['hydrated'] == null ? undefined : json['hydrated'],
+        'hydratedAt': json['hydratedAt'] == null ? undefined : (new Date(json['hydratedAt'])),
         'type': json['type'] == null ? undefined : json['type'],
         'vcpu': json['vcpu'] == null ? undefined : json['vcpu'],
         'memoryGB': json['memoryGB'] == null ? undefined : json['memoryGB'],
@@ -146,6 +150,7 @@ function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'setupError': json['setupError'] == null ? undefined : json['setupError'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'environmentVersion': json['environmentVersion'] == null ? undefined : json['environmentVersion'],
+        'stop': json['stop'] == null ? undefined : (0, StopOperation_1.StopOperationFromJSON)(json['stop']),
     };
 }
 function SandboxToJSON(json) {
@@ -163,6 +168,8 @@ function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'health': value['health'],
         'healthReason': value['healthReason'],
         'degradedSince': value['degradedSince'] == null ? value['degradedSince'] : value['degradedSince'].toISOString(),
+        'hydrated': value['hydrated'],
+        'hydratedAt': value['hydratedAt'] == null ? value['hydratedAt'] : value['hydratedAt'].toISOString(),
         'type': value['type'],
         'vcpu': value['vcpu'],
         'memoryGB': value['memoryGB'],
@@ -193,5 +200,6 @@ function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'setupError': value['setupError'],
         'environment': value['environment'],
         'environmentVersion': value['environmentVersion'],
+        'stop': (0, StopOperation_1.StopOperationToJSON)(value['stop']),
     };
 }

package/dist/models/SandboxUsageResponse.d.ts

@@ -40,7 +40,7 @@ export interface SandboxUsageResponse {
      */
     sandboxType: SandboxUsageResponseSandboxTypeEnum;
     /**
-     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, and 2 for `large`.
+     * Rate at which this sandbox consumes machine time. 0.5 for `small`, 1 for `default`, 2 for `large`, and 50/9 (about 5.56) for `xlarge`.
      * @type {number}
      * @memberof SandboxUsageResponse
      */
@@ -89,6 +89,7 @@ export declare const SandboxUsageResponseSandboxTypeEnum: {
     readonly Small: 'small';
     readonly Default: 'default';
     readonly Large: 'large';
+    readonly Xlarge: 'xlarge';
 };
 export type SandboxUsageResponseSandboxTypeEnum = typeof SandboxUsageResponseSandboxTypeEnum[keyof typeof SandboxUsageResponseSandboxTypeEnum];
 /**

package/dist/models/SandboxUsageResponse.js

@@ -25,7 +25,8 @@ exports.SandboxUsageResponseToJSONTyped = SandboxUsageResponseToJSONTyped;
 exports.SandboxUsageResponseSandboxTypeEnum = {
     Small: 'small',
     Default: 'default',
-    Large: 'large'
+    Large: 'large',
+    Xlarge: 'xlarge'
 };
 /**
  * Check if a given object implements the SandboxUsageResponse interface.