@boatdev/sdk 1.9.7 → 1.9.8

package/.openapi-generator/FILES

@@ -77,6 +77,7 @@ docs/HostPortResponse.md
 docs/LimitsFields.md
 docs/LimitsFieldsCurrentLimits.md
 docs/LimitsFieldsGiftLimit.md
+docs/LimitsFieldsMachineTypesInner.md
 docs/LimitsFieldsSandboxPlanTiersInner.md
 docs/LimitsFieldsStartLimits.md
 docs/LimitsFieldsStarts.md
@@ -126,6 +127,7 @@ docs/SandboxEnvironmentListResponse.md
 docs/SandboxEnvironmentResponse.md
 docs/SandboxEnvironmentVersionSummary.md
 docs/SandboxEvent.md
+docs/SandboxHydration.md
 docs/SandboxInfoResponse.md
 docs/SandboxListResponse.md
 docs/SandboxProcess.md
@@ -263,6 +265,7 @@ src/models/HostPortResponse.ts
 src/models/LimitsFields.ts
 src/models/LimitsFieldsCurrentLimits.ts
 src/models/LimitsFieldsGiftLimit.ts
+src/models/LimitsFieldsMachineTypesInner.ts
 src/models/LimitsFieldsSandboxPlanTiersInner.ts
 src/models/LimitsFieldsStartLimits.ts
 src/models/LimitsFieldsStarts.ts
@@ -312,6 +315,7 @@ src/models/SandboxEnvironmentListResponse.ts
 src/models/SandboxEnvironmentResponse.ts
 src/models/SandboxEnvironmentVersionSummary.ts
 src/models/SandboxEvent.ts
+src/models/SandboxHydration.ts
 src/models/SandboxInfoResponse.ts
 src/models/SandboxListResponse.ts
 src/models/SandboxProcess.ts

package/README.md

@@ -10,8 +10,8 @@ npm install @boatdev/sdk
 
 ## Links
 
-- SDK docs: https://docs.boat.dev/sdks
-- API reference: https://docs.boat.dev/api/reference
+- SDK docs: https://docs.boat.dev/sdks/overview
+- API reference: https://docs.boat.dev/api/v1
 - Dashboard: https://boat.dev/dashboard
 - API keys: https://boat.dev/dashboard?tab=api-keys
 

package/dist/apis/BoatApi.d.ts

@@ -1281,12 +1281,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     listCredentialAccountsRequestOpts(requestParameters: ListCredentialAccountsRequest): Promise<runtime.RequestOpts>;
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     listCredentialAccountsRaw(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>>;
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     listCredentialAccounts(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;

package/dist/apis/BoatApi.js

@@ -2716,7 +2716,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     async listCredentialAccountsRaw(requestParameters, initOverrides) {
@@ -2725,7 +2725,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, CredentialAccountsResponse_1.CredentialAccountsResponseFromJSON)(jsonValue));
     }
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     async listCredentialAccounts(requestParameters, initOverrides) {

package/dist/boat-helpers.d.ts

@@ -76,3 +76,26 @@ export type StreamCommandOptions = {
  * sent to a starting sandbox for up to 60 s instead of refusing it.
  */
 export declare function streamCommand(api: BoatApi, sandboxId: string, command: string, options?: StreamCommandOptions): AsyncGenerator<CommandFrame>;
+export type FollowCommandOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Yield a detached command's output from its start until it ends: `stdout`/`stderr`
+ * chunks (`frame.data`), then exactly one `exit` (`exitCode`, ...) or `error`
+ * (`message`). The server ends each connection after 10 minutes; this reconnects
+ * from the same offsets, with no gap and no repeat. A network cut is reconnected
+ * the same way for up to 60 s.
+ */
+export declare function followCommand(api: BoatApi, sandboxId: string, processId: number, options?: FollowCommandOptions): AsyncGenerator<CommandFrame>;
+export type RunCommandOptions = FollowCommandOptions & {
+    cwd?: string;
+};
+/**
+ * Run a command with no time limit and yield its output until it ends.
+ *
+ * The command runs detached, so it has no 600 s cap and survives a dropped
+ * connection. Frames: `{ type: 'started', processId }`, then the frames of
+ * `followCommand`. Stopping early leaves the command running: call
+ * `stopCommand({ sandboxId, processId })` to stop it.
+ */
+export declare function runCommand(api: BoatApi, sandboxId: string, command: string, options?: RunCommandOptions): AsyncGenerator<CommandFrame>;

package/dist/boat-helpers.js

@@ -12,6 +12,8 @@ exports.readText = readText;
 exports.writeText = writeText;
 exports.execCommand = execCommand;
 exports.streamCommand = streamCommand;
+exports.followCommand = followCommand;
+exports.runCommand = runCommand;
 const terminalPromptStatuses = new Set(['finished', 'failed']);
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -259,3 +261,98 @@ async function* streamCommand(api, sandboxId, command, options) {
         await delay(1000);
     }
 }
+// The server sends a heartbeat every 15 s, so 60 s of silence is a dead connection.
+const ATTACH_IDLE_MS = 60000;
+// After the first connection, a failed reconnect is tried again for this long.
+const ATTACH_RETRY_MS = 60000;
+function isNetworkError(e, signal) {
+    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || e instanceof SyntaxError)
+        return false;
+    return !(e === null || e === void 0 ? void 0 : e.response);
+}
+/**
+ * Yield a detached command's output from its start until it ends: `stdout`/`stderr`
+ * chunks (`frame.data`), then exactly one `exit` (`exitCode`, ...) or `error`
+ * (`message`). The server ends each connection after 10 minutes; this reconnects
+ * from the same offsets, with no gap and no repeat. A network cut is reconnected
+ * the same way for up to 60 s.
+ */
+async function* followCommand(api, sandboxId, processId, options) {
+    var _a, _b, _c;
+    var _d, _e, _f, _g;
+    const offsets = { stdout: 0, stderr: 0 };
+    let connected = false;
+    // Set at the first failure after a good connection; any good connection clears it.
+    let failingSince;
+    for (;;) {
+        if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+            throw (_d = options.signal.reason) !== null && _d !== void 0 ? _d : new Error('followCommand aborted');
+        // One controller per connection: the caller's signal, or 60 s with no line.
+        const connection = new AbortController();
+        const abort = () => connection.abort();
+        (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', abort);
+        let idle;
+        const touch = () => {
+            clearTimeout(idle);
+            idle = setTimeout(abort, ATTACH_IDLE_MS);
+        };
+        try {
+            touch();
+            const response = await api.attachCommandRaw({ sandboxId, processId, stdoutOffset: offsets.stdout, stderrOffset: offsets.stderr }, { signal: connection.signal });
+            connected = true;
+            failingSince = undefined;
+            for await (const frame of ndjsonFrames(response.raw)) {
+                touch();
+                if (frame.type === 'stdout' || frame.type === 'stderr') {
+                    offsets[frame.type] = (_e = frame.nextOffset) !== null && _e !== void 0 ? _e : offsets[frame.type];
+                    yield frame;
+                }
+                else if (frame.type === 'exit' || frame.type === 'error') {
+                    yield frame;
+                    return;
+                }
+                else {
+                    // attached, heartbeat, reconnect: ours to handle, never the caller's.
+                    offsets.stdout = (_f = frame.stdoutOffset) !== null && _f !== void 0 ? _f : offsets.stdout;
+                    offsets.stderr = (_g = frame.stderrOffset) !== null && _g !== void 0 ? _g : offsets.stderr;
+                }
+            }
+        }
+        catch (e) {
+            failingSince !== null && failingSince !== void 0 ? failingSince : (failingSince = Date.now());
+            if (!isNetworkError(e, options === null || options === void 0 ? void 0 : options.signal) || !connected || Date.now() - failingSince >= ATTACH_RETRY_MS)
+                throw e;
+            await delay(1000);
+        }
+        finally {
+            clearTimeout(idle);
+            (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.removeEventListener('abort', abort);
+        }
+    }
+}
+/**
+ * Run a command with no time limit and yield its output until it ends.
+ *
+ * The command runs detached, so it has no 600 s cap and survives a dropped
+ * connection. Frames: `{ type: 'started', processId }`, then the frames of
+ * `followCommand`. Stopping early leaves the command running: call
+ * `stopCommand({ sandboxId, processId })` to stop it.
+ */
+async function* runCommand(api, sandboxId, command, options) {
+    const deadline = Date.now() + STREAM_RETRY_MS;
+    let processId;
+    for (;;) {
+        try {
+            const started = await api.command({ sandboxId, commandRequest: { command, cwd: options === null || options === void 0 ? void 0 : options.cwd, detached: true } });
+            processId = started.processId;
+            break;
+        }
+        catch (e) {
+            if (Date.now() + 1000 >= deadline || !(await isRetryable(e)))
+                throw e;
+        }
+        await delay(1000);
+    }
+    yield { type: 'started', processId };
+    yield* followCommand(api, sandboxId, processId, options);
+}

package/dist/esm/apis/BoatApi.d.ts

@@ -1281,12 +1281,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     listCredentialAccountsRequestOpts(requestParameters: ListCredentialAccountsRequest): Promise<runtime.RequestOpts>;
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     listCredentialAccountsRaw(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>>;
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     listCredentialAccounts(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;

package/dist/esm/apis/BoatApi.js

@@ -2680,7 +2680,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     async listCredentialAccountsRaw(requestParameters, initOverrides) {
@@ -2689,7 +2689,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => CredentialAccountsResponseFromJSON(jsonValue));
     }
     /**
-     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`, on a profile you manage: an org member who only uses an org profile gets `403`.
      * List the accounts of a credential
      */
     async listCredentialAccounts(requestParameters, initOverrides) {

package/dist/esm/boat-helpers.d.ts

@@ -76,3 +76,26 @@ export type StreamCommandOptions = {
  * sent to a starting sandbox for up to 60 s instead of refusing it.
  */
 export declare function streamCommand(api: BoatApi, sandboxId: string, command: string, options?: StreamCommandOptions): AsyncGenerator<CommandFrame>;
+export type FollowCommandOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Yield a detached command's output from its start until it ends: `stdout`/`stderr`
+ * chunks (`frame.data`), then exactly one `exit` (`exitCode`, ...) or `error`
+ * (`message`). The server ends each connection after 10 minutes; this reconnects
+ * from the same offsets, with no gap and no repeat. A network cut is reconnected
+ * the same way for up to 60 s.
+ */
+export declare function followCommand(api: BoatApi, sandboxId: string, processId: number, options?: FollowCommandOptions): AsyncGenerator<CommandFrame>;
+export type RunCommandOptions = FollowCommandOptions & {
+    cwd?: string;
+};
+/**
+ * Run a command with no time limit and yield its output until it ends.
+ *
+ * The command runs detached, so it has no 600 s cap and survives a dropped
+ * connection. Frames: `{ type: 'started', processId }`, then the frames of
+ * `followCommand`. Stopping early leaves the command running: call
+ * `stopCommand({ sandboxId, processId })` to stop it.
+ */
+export declare function runCommand(api: BoatApi, sandboxId: string, command: string, options?: RunCommandOptions): AsyncGenerator<CommandFrame>;

package/dist/esm/boat-helpers.js

@@ -245,3 +245,98 @@ export async function* streamCommand(api, sandboxId, command, options) {
         await delay(1000);
     }
 }
+// The server sends a heartbeat every 15 s, so 60 s of silence is a dead connection.
+const ATTACH_IDLE_MS = 60000;
+// After the first connection, a failed reconnect is tried again for this long.
+const ATTACH_RETRY_MS = 60000;
+function isNetworkError(e, signal) {
+    if ((signal === null || signal === void 0 ? void 0 : signal.aborted) || e instanceof SyntaxError)
+        return false;
+    return !(e === null || e === void 0 ? void 0 : e.response);
+}
+/**
+ * Yield a detached command's output from its start until it ends: `stdout`/`stderr`
+ * chunks (`frame.data`), then exactly one `exit` (`exitCode`, ...) or `error`
+ * (`message`). The server ends each connection after 10 minutes; this reconnects
+ * from the same offsets, with no gap and no repeat. A network cut is reconnected
+ * the same way for up to 60 s.
+ */
+export async function* followCommand(api, sandboxId, processId, options) {
+    var _a, _b, _c;
+    var _d, _e, _f, _g;
+    const offsets = { stdout: 0, stderr: 0 };
+    let connected = false;
+    // Set at the first failure after a good connection; any good connection clears it.
+    let failingSince;
+    for (;;) {
+        if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted)
+            throw (_d = options.signal.reason) !== null && _d !== void 0 ? _d : new Error('followCommand aborted');
+        // One controller per connection: the caller's signal, or 60 s with no line.
+        const connection = new AbortController();
+        const abort = () => connection.abort();
+        (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', abort);
+        let idle;
+        const touch = () => {
+            clearTimeout(idle);
+            idle = setTimeout(abort, ATTACH_IDLE_MS);
+        };
+        try {
+            touch();
+            const response = await api.attachCommandRaw({ sandboxId, processId, stdoutOffset: offsets.stdout, stderrOffset: offsets.stderr }, { signal: connection.signal });
+            connected = true;
+            failingSince = undefined;
+            for await (const frame of ndjsonFrames(response.raw)) {
+                touch();
+                if (frame.type === 'stdout' || frame.type === 'stderr') {
+                    offsets[frame.type] = (_e = frame.nextOffset) !== null && _e !== void 0 ? _e : offsets[frame.type];
+                    yield frame;
+                }
+                else if (frame.type === 'exit' || frame.type === 'error') {
+                    yield frame;
+                    return;
+                }
+                else {
+                    // attached, heartbeat, reconnect: ours to handle, never the caller's.
+                    offsets.stdout = (_f = frame.stdoutOffset) !== null && _f !== void 0 ? _f : offsets.stdout;
+                    offsets.stderr = (_g = frame.stderrOffset) !== null && _g !== void 0 ? _g : offsets.stderr;
+                }
+            }
+        }
+        catch (e) {
+            failingSince !== null && failingSince !== void 0 ? failingSince : (failingSince = Date.now());
+            if (!isNetworkError(e, options === null || options === void 0 ? void 0 : options.signal) || !connected || Date.now() - failingSince >= ATTACH_RETRY_MS)
+                throw e;
+            await delay(1000);
+        }
+        finally {
+            clearTimeout(idle);
+            (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.removeEventListener('abort', abort);
+        }
+    }
+}
+/**
+ * Run a command with no time limit and yield its output until it ends.
+ *
+ * The command runs detached, so it has no 600 s cap and survives a dropped
+ * connection. Frames: `{ type: 'started', processId }`, then the frames of
+ * `followCommand`. Stopping early leaves the command running: call
+ * `stopCommand({ sandboxId, processId })` to stop it.
+ */
+export async function* runCommand(api, sandboxId, command, options) {
+    const deadline = Date.now() + STREAM_RETRY_MS;
+    let processId;
+    for (;;) {
+        try {
+            const started = await api.command({ sandboxId, commandRequest: { command, cwd: options === null || options === void 0 ? void 0 : options.cwd, detached: true } });
+            processId = started.processId;
+            break;
+        }
+        catch (e) {
+            if (Date.now() + 1000 >= deadline || !(await isRetryable(e)))
+                throw e;
+        }
+        await delay(1000);
+    }
+    yield { type: 'started', processId };
+    yield* followCommand(api, sandboxId, processId, options);
+}

package/dist/esm/models/CredentialProfile.d.ts

@@ -55,7 +55,7 @@ export interface CredentialProfile {
      */
     connected: Array<CredentialId>;
     /**
-     * Credentials with several accounts, keyed by credential id. Each lists every account (labels only), the one in use marked `active`.
+     * Credentials with several accounts, keyed by credential id. Each lists every account (labels only), the one in use marked `active`. Empty when you cannot manage the profile.
      * @type {{ [key: string]: Array<CredentialAccount>; }}
      * @memberof CredentialProfile
      */

package/dist/esm/models/DeletionOperation.d.ts

@@ -46,7 +46,7 @@ export interface DeletionOperation {
      */
     status: DeletionOperationStatusEnum;
     /**
-     * What the background purge is doing. The target is already gone from every list, restore and fork once the operation exists. `waiting_for_uploads`: stored data is erased once the last upload URL issued for it expires (`expectedBy`). `kept_for_newer_snapshots`: a newer snapshot, or a sandbox forked or deployed from it, still builds on this data; it goes when they go. `waiting_for_restore`: a sandbox is still restoring from it. `retrying`: a transient fault, retried automatically.
+     * What the background purge is doing. The target is already gone from every list, restore and fork once the operation exists. `waiting_for_uploads`: stored data is erased once the last upload URL issued for it expires (`expectedBy`). `retrying`: a transient fault, retried automatically. `completed`: a newer snapshot, a fork or a named snapshot made from it keeps the data it reads, until that is deleted too.
      * @type {DeletionOperationStageEnum}
      * @memberof DeletionOperation
      */
@@ -109,8 +109,6 @@ export type DeletionOperationStatusEnum = typeof DeletionOperationStatusEnum[key
 export declare const DeletionOperationStageEnum: {
     readonly Removing: 'removing';
     readonly WaitingForUploads: 'waiting_for_uploads';
-    readonly KeptForNewerSnapshots: 'kept_for_newer_snapshots';
-    readonly WaitingForRestore: 'waiting_for_restore';
     readonly Retrying: 'retrying';
     readonly Completed: 'completed';
 };

package/dist/esm/models/DeletionOperation.js

@@ -41,8 +41,6 @@ export const DeletionOperationStatusEnum = {
 export const DeletionOperationStageEnum = {
     Removing: 'removing',
     WaitingForUploads: 'waiting_for_uploads',
-    KeptForNewerSnapshots: 'kept_for_newer_snapshots',
-    WaitingForRestore: 'waiting_for_restore',
     Retrying: 'retrying',
     Completed: 'completed'
 };

package/dist/esm/models/LimitsFields.d.ts

@@ -11,6 +11,7 @@
  */
 import type { LimitsFieldsGiftLimit } from './LimitsFieldsGiftLimit';
 import type { LimitsFieldsCurrentLimits } from './LimitsFieldsCurrentLimits';
+import type { LimitsFieldsMachineTypesInner } from './LimitsFieldsMachineTypesInner';
 import type { LimitsFieldsStartLimits } from './LimitsFieldsStartLimits';
 import type { LimitsFieldsStarts } from './LimitsFieldsStarts';
 import type { LimitsFieldsSandboxPlanTiersInner } from './LimitsFieldsSandboxPlanTiersInner';
@@ -271,6 +272,12 @@ export interface LimitsFields {
      * @memberof LimitsFields
      */
     trialLine?: string | null;
+    /**
+     * Each sandbox type, and whether this account can create it now. A blocked type carries the reason.
+     * @type {Array<LimitsFieldsMachineTypesInner>}
+     * @memberof LimitsFields
+     */
+    machineTypes?: Array<LimitsFieldsMachineTypesInner>;
     /**
      *
      * @type {LimitsFieldsGiftLimit}

package/dist/esm/models/LimitsFields.js

@@ -13,6 +13,7 @@
  */
 import { LimitsFieldsGiftLimitFromJSON, LimitsFieldsGiftLimitToJSON, } from './LimitsFieldsGiftLimit';
 import { LimitsFieldsCurrentLimitsFromJSON, LimitsFieldsCurrentLimitsToJSON, } from './LimitsFieldsCurrentLimits';
+import { LimitsFieldsMachineTypesInnerFromJSON, LimitsFieldsMachineTypesInnerToJSON, } from './LimitsFieldsMachineTypesInner';
 import { LimitsFieldsStartLimitsFromJSON, LimitsFieldsStartLimitsToJSON, } from './LimitsFieldsStartLimits';
 import { LimitsFieldsStartsFromJSON, LimitsFieldsStartsToJSON, } from './LimitsFieldsStarts';
 import { LimitsFieldsSandboxPlanTiersInnerFromJSON, LimitsFieldsSandboxPlanTiersInnerToJSON, } from './LimitsFieldsSandboxPlanTiersInner';
@@ -80,6 +81,7 @@ export function LimitsFieldsFromJSONTyped(json, ignoreDiscriminator) {
         'last24hUsageSeconds': json['last24hUsageSeconds'] == null ? undefined : json['last24hUsageSeconds'],
         'trialComputeCapSeconds': json['trialComputeCapSeconds'] == null ? undefined : json['trialComputeCapSeconds'],
         'trialLine': json['trialLine'] == null ? undefined : json['trialLine'],
+        'machineTypes': json['machineTypes'] == null ? undefined : (json['machineTypes'].map(LimitsFieldsMachineTypesInnerFromJSON)),
         'giftLimit': json['giftLimit'] == null ? undefined : LimitsFieldsGiftLimitFromJSON(json['giftLimit']),
         'billingStatus': json['billingStatus'],
         'subscriptionStatus': json['subscriptionStatus'] == null ? undefined : json['subscriptionStatus'],
@@ -142,6 +144,7 @@ export function LimitsFieldsToJSONTyped(value, ignoreDiscriminator = false) {
         'last24hUsageSeconds': value['last24hUsageSeconds'],
         'trialComputeCapSeconds': value['trialComputeCapSeconds'],
         'trialLine': value['trialLine'],
+        'machineTypes': value['machineTypes'] == null ? undefined : (value['machineTypes'].map(LimitsFieldsMachineTypesInnerToJSON)),
         'giftLimit': LimitsFieldsGiftLimitToJSON(value['giftLimit']),
         'billingStatus': value['billingStatus'],
         'subscriptionStatus': value['subscriptionStatus'],

package/dist/esm/models/LimitsFieldsMachineTypesInner.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 LimitsFieldsMachineTypesInner
+ */
+export interface LimitsFieldsMachineTypesInner {
+    /**
+     *
+     * @type {LimitsFieldsMachineTypesInnerTypeEnum}
+     * @memberof LimitsFieldsMachineTypesInner
+     */
+    type: LimitsFieldsMachineTypesInnerTypeEnum;
+    /**
+     *
+     * @type {boolean}
+     * @memberof LimitsFieldsMachineTypesInner
+     */
+    available: boolean;
+    /**
+     * Why the type is blocked, for example `not during the free trial; the first payment unlocks it`. Null when available.
+     * @type {string}
+     * @memberof LimitsFieldsMachineTypesInner
+     */
+    reason: string | null;
+}
+/**
+ * @export
+ */
+export declare const LimitsFieldsMachineTypesInnerTypeEnum: {
+    readonly Small: 'small';
+    readonly Default: 'default';
+    readonly Large: 'large';
+    readonly Xlarge: 'xlarge';
+};
+export type LimitsFieldsMachineTypesInnerTypeEnum = typeof LimitsFieldsMachineTypesInnerTypeEnum[keyof typeof LimitsFieldsMachineTypesInnerTypeEnum];
+/**
+ * Check if a given object implements the LimitsFieldsMachineTypesInner interface.
+ */
+export declare function instanceOfLimitsFieldsMachineTypesInner(value: object): value is LimitsFieldsMachineTypesInner;
+export declare function LimitsFieldsMachineTypesInnerFromJSON(json: any): LimitsFieldsMachineTypesInner;
+export declare function LimitsFieldsMachineTypesInnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): LimitsFieldsMachineTypesInner;
+export declare function LimitsFieldsMachineTypesInnerToJSON(json: any): LimitsFieldsMachineTypesInner;
+export declare function LimitsFieldsMachineTypesInnerToJSONTyped(value?: LimitsFieldsMachineTypesInner | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/LimitsFieldsMachineTypesInner.js

@@ -0,0 +1,60 @@
+/* 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.
+ */
+/**
+ * @export
+ */
+export const LimitsFieldsMachineTypesInnerTypeEnum = {
+    Small: 'small',
+    Default: 'default',
+    Large: 'large',
+    Xlarge: 'xlarge'
+};
+/**
+ * Check if a given object implements the LimitsFieldsMachineTypesInner interface.
+ */
+export function instanceOfLimitsFieldsMachineTypesInner(value) {
+    if (!('type' in value) || value['type'] === undefined)
+        return false;
+    if (!('available' in value) || value['available'] === undefined)
+        return false;
+    if (!('reason' in value) || value['reason'] === undefined)
+        return false;
+    return true;
+}
+export function LimitsFieldsMachineTypesInnerFromJSON(json) {
+    return LimitsFieldsMachineTypesInnerFromJSONTyped(json, false);
+}
+export function LimitsFieldsMachineTypesInnerFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'type': json['type'],
+        'available': json['available'],
+        'reason': json['reason'],
+    };
+}
+export function LimitsFieldsMachineTypesInnerToJSON(json) {
+    return LimitsFieldsMachineTypesInnerToJSONTyped(json, false);
+}
+export function LimitsFieldsMachineTypesInnerToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'type': value['type'],
+        'available': value['available'],
+        'reason': value['reason'],
+    };
+}

package/dist/esm/models/LimitsResponse.d.ts

@@ -11,6 +11,7 @@
  */
 import type { LimitsFieldsGiftLimit } from './LimitsFieldsGiftLimit';
 import type { LimitsFieldsCurrentLimits } from './LimitsFieldsCurrentLimits';
+import type { LimitsFieldsMachineTypesInner } from './LimitsFieldsMachineTypesInner';
 import type { LimitsFieldsStartLimits } from './LimitsFieldsStartLimits';
 import type { LimitsFieldsStarts } from './LimitsFieldsStarts';
 import type { LimitsFieldsSandboxPlanTiersInner } from './LimitsFieldsSandboxPlanTiersInner';
@@ -282,6 +283,12 @@ export interface LimitsResponse {
      * @memberof LimitsResponse
      */
     trialLine?: string;
+    /**
+     * Each sandbox type, and whether this account can create it now. A blocked type carries the reason.
+     * @type {Array<LimitsFieldsMachineTypesInner>}
+     * @memberof LimitsResponse
+     */
+    machineTypes?: Array<LimitsFieldsMachineTypesInner>;
     /**
      *
      * @type {LimitsFieldsGiftLimit}

package/dist/esm/models/LimitsResponse.js

@@ -13,6 +13,7 @@
  */
 import { LimitsFieldsGiftLimitFromJSON, LimitsFieldsGiftLimitToJSON, } from './LimitsFieldsGiftLimit';
 import { LimitsFieldsCurrentLimitsFromJSON, LimitsFieldsCurrentLimitsToJSON, } from './LimitsFieldsCurrentLimits';
+import { LimitsFieldsMachineTypesInnerFromJSON, LimitsFieldsMachineTypesInnerToJSON, } from './LimitsFieldsMachineTypesInner';
 import { LimitsFieldsStartLimitsFromJSON, LimitsFieldsStartLimitsToJSON, } from './LimitsFieldsStartLimits';
 import { LimitsFieldsStartsFromJSON, LimitsFieldsStartsToJSON, } from './LimitsFieldsStarts';
 import { LimitsFieldsSandboxPlanTiersInnerFromJSON, LimitsFieldsSandboxPlanTiersInnerToJSON, } from './LimitsFieldsSandboxPlanTiersInner';
@@ -85,6 +86,7 @@ export function LimitsResponseFromJSONTyped(json, ignoreDiscriminator) {
         'last24hUsageSeconds': json['last24hUsageSeconds'] == null ? undefined : json['last24hUsageSeconds'],
         'trialComputeCapSeconds': json['trialComputeCapSeconds'] == null ? undefined : json['trialComputeCapSeconds'],
         'trialLine': json['trialLine'] == null ? undefined : json['trialLine'],
+        'machineTypes': json['machineTypes'] == null ? undefined : (json['machineTypes'].map(LimitsFieldsMachineTypesInnerFromJSON)),
         'giftLimit': json['giftLimit'] == null ? undefined : LimitsFieldsGiftLimitFromJSON(json['giftLimit']),
         'billingStatus': json['billingStatus'],
         'subscriptionStatus': json['subscriptionStatus'] == null ? undefined : json['subscriptionStatus'],
@@ -148,6 +150,7 @@ export function LimitsResponseToJSONTyped(value, ignoreDiscriminator = false) {
         'last24hUsageSeconds': value['last24hUsageSeconds'],
         'trialComputeCapSeconds': value['trialComputeCapSeconds'],
         'trialLine': value['trialLine'],
+        'machineTypes': value['machineTypes'] == null ? undefined : (value['machineTypes'].map(LimitsFieldsMachineTypesInnerToJSON)),
         'giftLimit': LimitsFieldsGiftLimitToJSON(value['giftLimit']),
         'billingStatus': value['billingStatus'],
         'subscriptionStatus': value['subscriptionStatus'],