@boatdev/sdk 1.9.8 → 1.10.0

package/dist/esm/apis/BoatApi.js

@@ -104,8 +104,11 @@ import { StopRequestToJSON, } from '../models/StopRequest';
 import { TelemetryResponseFromJSON, } from '../models/TelemetryResponse';
 import { TelemetrySetRequestToJSON, } from '../models/TelemetrySetRequest';
 import { TelemetrySetResponseFromJSON, } from '../models/TelemetrySetResponse';
+import { Unshare200ResponseFromJSON, } from '../models/Unshare200Response';
 import { UpdateAiProxyRequestToJSON, } from '../models/UpdateAiProxyRequest';
 import { UpdateCredentialProfileRequestToJSON, } from '../models/UpdateCredentialProfileRequest';
+import { UpdateOrganization200ResponseFromJSON, } from '../models/UpdateOrganization200Response';
+import { UpdateOrganizationRequestToJSON, } from '../models/UpdateOrganizationRequest';
 import { UpdateSandboxEnvironmentRequestToJSON, } from '../models/UpdateSandboxEnvironmentRequest';
 import { UpdateSandboxRequestToJSON, } from '../models/UpdateSandboxRequest';
 import { UpgradeSandboxEnvironmentRequestToJSON, } from '../models/UpgradeSandboxEnvironmentRequest';
@@ -2239,7 +2242,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * One sandbox\'s proxied AI usage per UTC day, credential and model, and whether it is blocked. Needs an API key with `box.read` on the sandbox.
+     * One sandbox\'s proxied AI usage per UTC day, credential and model, and whether it is blocked. Needs an API key with `sandbox.read` on the sandbox.
      * Get sandbox AI usage
      */
     async getSandboxAiUsageRaw(requestParameters, initOverrides) {
@@ -2248,7 +2251,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => SandboxAiUsageResponseFromJSON(jsonValue));
     }
     /**
-     * One sandbox\'s proxied AI usage per UTC day, credential and model, and whether it is blocked. Needs an API key with `box.read` on the sandbox.
+     * One sandbox\'s proxied AI usage per UTC day, credential and model, and whether it is blocked. Needs an API key with `sandbox.read` on the sandbox.
      * Get sandbox AI usage
      */
     async getSandboxAiUsage(requestParameters, initOverrides) {
@@ -3239,7 +3242,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or stop it with `{\"force\": true}` and resume it from its last   good snapshot. With no snapshot, a forced stop loses everything. - `reset_failed`: the power-cycle failed. Reply to the incident email.
      * Recover a sandbox that stopped responding
      */
     async recoverRaw(requestParameters, initOverrides) {
@@ -3248,7 +3251,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => Recover200ResponseFromJSON(jsonValue));
     }
     /**
-     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or stop it with `{\"force\": true}` and resume it from its last   good snapshot. With no snapshot, a forced stop loses everything. - `reset_failed`: the power-cycle failed. Reply to the incident email.
      * Recover a sandbox that stopped responding
      */
     async recover(requestParameters, initOverrides) {
@@ -3546,6 +3549,9 @@ export class BoatApi extends runtime.BaseAPI {
         if (requestParameters['state'] != null) {
             queryParameters['state'] = requestParameters['state'];
         }
+        if (requestParameters['include'] != null) {
+            queryParameters['include'] = requestParameters['include'];
+        }
         const headerParameters = {};
         if (requestParameters['xBoatOrg'] != null) {
             headerParameters['X-Boat-Org'] = String(requestParameters['xBoatOrg']);
@@ -4080,7 +4086,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Let every member of the organization that pays for this sandbox use it.  A sandbox that holds none of your personal logins is shared at once.  A sandbox that holds them: your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. The wipe is one-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`): its running programs hold your logins in memory.  Teammates never read history recorded before the share.  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op. Undo with `POST /sandboxes/{sandboxId}/unshare`.
      * Share sandbox with the organization
      */
     async shareRaw(requestParameters, initOverrides) {
@@ -4089,7 +4095,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => Share200ResponseFromJSON(jsonValue));
     }
     /**
-     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Let every member of the organization that pays for this sandbox use it.  A sandbox that holds none of your personal logins is shared at once.  A sandbox that holds them: your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. The wipe is one-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`): its running programs hold your logins in memory.  Teammates never read history recorded before the share.  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op. Undo with `POST /sandboxes/{sandboxId}/unshare`.
      * Share sandbox with the organization
      */
     async share(requestParameters, initOverrides) {
@@ -4336,6 +4342,48 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.switchCredentialAccountRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for unshare without sending the request
+     */
+    async unshareRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling unshare().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/unshare`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Make a shared organization sandbox private again, at once. Only you can then use it. Teammates still see it in their list and can stop it. Their SSH keys are removed from the running machine.  Nothing on the sandbox changes: files, installs and its environment stay. Undo with `POST /sandboxes/{sandboxId}/share`.  Only the person who created the sandbox can make it private, and only a sandbox billed to an organization. Making a private sandbox private is a no-op.
+     * Make an organization sandbox private
+     */
+    async unshareRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.unshareRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => Unshare200ResponseFromJSON(jsonValue));
+    }
+    /**
+     * Make a shared organization sandbox private again, at once. Only you can then use it. Teammates still see it in their list and can stop it. Their SSH keys are removed from the running machine.  Nothing on the sandbox changes: files, installs and its environment stay. Undo with `POST /sandboxes/{sandboxId}/share`.  Only the person who created the sandbox can make it private, and only a sandbox billed to an organization. Making a private sandbox private is a no-op.
+     * Make an organization sandbox private
+     */
+    async unshare(requestParameters, initOverrides) {
+        const response = await this.unshareRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for update without sending the request
      */
@@ -4575,6 +4623,54 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.updateEnvironmentRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for updateOrganization without sending the request
+     */
+    async updateOrganizationRequestOpts(input) {
+        const requestParameters = runtime.unflattenBody(input, 'updateOrganizationRequest', ['org'], []);
+        if (requestParameters['org'] == null) {
+            throw new runtime.RequiredError('org', 'Required parameter "org" was null or undefined when calling updateOrganization().');
+        }
+        if (requestParameters['updateOrganizationRequest'] == null) {
+            throw new runtime.RequiredError('updateOrganizationRequest', 'Required parameter "updateOrganizationRequest" was null or undefined when calling updateOrganization().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/orgs/{org}`;
+        urlPath = urlPath.replace('{org}', encodeURIComponent(String(requestParameters['org'])));
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: UpdateOrganizationRequestToJSON(requestParameters['updateOrganizationRequest']),
+        };
+    }
+    /**
+     * Owners and admins set whether new sandboxes of the organization start private (only their creator can use them) or shared (every member can use those that hold none of their creator\'s logins). The default is shared. Existing sandboxes keep their setting; their creators change it with `POST /sandboxes/{sandboxId}/share` and `POST /sandboxes/{sandboxId}/unshare`. A fork of a private sandbox is private.
+     * Update organization settings
+     */
+    async updateOrganizationRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.updateOrganizationRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => UpdateOrganization200ResponseFromJSON(jsonValue));
+    }
+    /**
+     * Owners and admins set whether new sandboxes of the organization start private (only their creator can use them) or shared (every member can use those that hold none of their creator\'s logins). The default is shared. Existing sandboxes keep their setting; their creators change it with `POST /sandboxes/{sandboxId}/share` and `POST /sandboxes/{sandboxId}/unshare`. A fork of a private sandbox is private.
+     * Update organization settings
+     */
+    async updateOrganization(requestParameters, initOverrides) {
+        const response = await this.updateOrganizationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for updateSecrets without sending the request
      */
@@ -4879,3 +4975,9 @@ export const SandboxesSortEnum = {
     Asc: 'asc',
     Desc: 'desc'
 };
+/**
+ * @export
+ */
+export const SandboxesIncludeEnum = {
+    Cost: 'cost'
+};

package/dist/esm/http2-fetch.js

@@ -168,28 +168,36 @@ async function http2Fetch(input, init = {}) {
             // 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.
+            // A reader that cancels (it stopped early) closes the body; data, 'end' or
+            // 'error' still in flight must then do nothing. Calling close() on it threw
+            // from an event handler and killed the process (prod, 2026-10-14).
+            let open = true;
+            const finish = (settle) => {
+                if (!open)
+                    return;
+                open = false;
+                settle();
+            };
             const bodyStream = empty ? null : new ReadableStream({
                 start(controller) {
                     req.on('data', (chunk) => {
                         var _a;
+                        if (!open)
+                            return;
                         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('end', () => finish(() => controller.close()));
+                    req.once('error', (e) => finish(() => 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) { }
-                        }
+                        if (!req.readableEnded)
+                            finish(() => controller.error(new Error(`HTTP/2 stream closed before its end (code ${req.rstCode})`)));
                     });
                 },
                 pull() { if (req.isPaused())
                     req.resume(); },
-                cancel() { req.close(); },
+                cancel() { open = false; 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.

package/dist/esm/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). `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.
+     * 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, or an account access grant from an administrator. Otherwise, create, resume and fork return 403 `machine_class_plan_required`. 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
      */
@@ -65,6 +65,12 @@ export interface CreateSandboxRequest {
      * @memberof CreateSandboxRequest
      */
     failFast?: boolean;
+    /**
+     * With `from`: create this many sandboxes from the named snapshot in one request. Boat creates them together, which is faster than separate creates when you need many sandboxes at once. Start limits and the active-sandbox limit count every sandbox of the batch; if the batch does not fit, nothing is created. The answer lists all of them in `sandboxes` (and the first one in `sandbox`). Refused with 400 `count_requires_from` without `from`, and with 400 `count_with_fail_fast` together with `failFast`.
+     * @type {number}
+     * @memberof CreateSandboxRequest
+     */
+    count?: number;
     /**
      * 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}

package/dist/esm/models/CreateSandboxRequest.js

@@ -42,6 +42,7 @@ export function CreateSandboxRequestFromJSONTyped(json, ignoreDiscriminator) {
         'snapshots': json['snapshots'] == null ? undefined : json['snapshots'],
         'monitoring': json['monitoring'] == null ? undefined : json['monitoring'],
         'failFast': json['failFast'] == null ? undefined : json['failFast'],
+        'count': json['count'] == null ? undefined : json['count'],
         'setupScript': json['setupScript'] == null ? undefined : json['setupScript'],
         'org': json['org'] == null ? undefined : json['org'],
         'teamId': json['teamId'] == null ? undefined : json['teamId'],
@@ -64,6 +65,7 @@ export function CreateSandboxRequestToJSONTyped(value, ignoreDiscriminator = fal
         'snapshots': value['snapshots'],
         'monitoring': value['monitoring'],
         'failFast': value['failFast'],
+        'count': value['count'],
         'setupScript': value['setupScript'],
         'org': value['org'],
         'teamId': value['teamId'],

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

@@ -46,6 +46,12 @@ export interface CreateSandboxResponse {
      * @memberof CreateSandboxResponse
      */
     sandbox: Sandbox;
+    /**
+     * Present when the request set `count` above 1. Every sandbox of the batch, in creation order.
+     * @type {Array<Sandbox>}
+     * @memberof CreateSandboxResponse
+     */
+    sandboxes?: Array<Sandbox>;
     /**
      * Present when a fair-use cap on a gifted account shortened the requested auto-stop time.
      * @type {string}

package/dist/esm/models/CreateSandboxResponse.js

@@ -54,6 +54,7 @@ export function CreateSandboxResponseFromJSONTyped(json, ignoreDiscriminator) {
         'status': json['status'],
         'ttlSeconds': json['ttlSeconds'],
         'sandbox': SandboxFromJSON(json['sandbox']),
+        'sandboxes': json['sandboxes'] == null ? undefined : (json['sandboxes'].map(SandboxFromJSON)),
         'giftLimitNotice': json['giftLimitNotice'] == null ? undefined : json['giftLimitNotice'],
     };
 }
@@ -70,6 +71,7 @@ export function CreateSandboxResponseToJSONTyped(value, ignoreDiscriminator = fa
         'status': value['status'],
         'ttlSeconds': value['ttlSeconds'],
         'sandbox': SandboxToJSON(value['sandbox']),
+        'sandboxes': value['sandboxes'] == null ? undefined : (value['sandboxes'].map(SandboxToJSON)),
         'giftLimitNotice': value['giftLimitNotice'],
     };
 }

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

@@ -22,7 +22,7 @@ export interface CreateScopedApiKeyRequest {
      */
     name?: string;
     /**
-     * Duration such as 90d, 24h, or seconds. Max 365d.
+     * Duration such as 90d, 24h, or seconds, up to 365d; or `never` for a key that works until revoked. Default 90d.
      * @type {string}
      * @memberof CreateScopedApiKeyRequest
      */

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

@@ -261,7 +261,7 @@ export interface LimitsFields {
      */
     last24hUsageSeconds?: number;
     /**
-     * Lifetime machine-time allowance for a trial that never paid. Null once the account has paid or has a plan.
+     * Lifetime Boat-time allowance for new sandboxes while the account has not paid, a plan trial included. Every charge on the wallet counts. Null once the account has paid.
      * @type {number}
      * @memberof LimitsFields
      */

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

@@ -272,7 +272,7 @@ export interface LimitsResponse {
      */
     last24hUsageSeconds?: number;
     /**
-     * Lifetime machine-time allowance for a trial that never paid. Null once the account has paid or has a plan.
+     * Lifetime Boat-time allowance for new sandboxes while the account has not paid, a plan trial included. Every charge on the wallet counts. Null once the account has paid.
      * @type {number}
      * @memberof LimitsResponse
      */

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

@@ -137,6 +137,7 @@ export declare const MeResponseAllOfUserConnectionMethodEnum: {
     readonly Github: 'github';
     readonly Google: 'google';
     readonly Email: 'email';
+    readonly Agentid: 'agentid';
     readonly Service: 'service';
 };
 export type MeResponseAllOfUserConnectionMethodEnum = typeof MeResponseAllOfUserConnectionMethodEnum[keyof typeof MeResponseAllOfUserConnectionMethodEnum];

package/dist/esm/models/MeResponseAllOfUser.js

@@ -18,6 +18,7 @@ export const MeResponseAllOfUserConnectionMethodEnum = {
     Github: 'github',
     Google: 'google',
     Email: 'email',
+    Agentid: 'agentid',
     Service: 'service'
 };
 /**

package/dist/esm/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. `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.
+     * Resume onto a different machine size. Omit to keep the sandbox's current type. `xlarge` needs the $100/month plan or higher, or an account access grant from an administrator (403 `machine_class_plan_required` otherwise). 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
      */

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

@@ -11,6 +11,7 @@
  */
 import type { SandboxTeam } from './SandboxTeam';
 import type { StopOperation } from './StopOperation';
+import type { SandboxCost } from './SandboxCost';
 import type { SandboxHydration } from './SandboxHydration';
 /**
  *
@@ -42,6 +43,12 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     error?: string | null;
+    /**
+     * When Boat deleted the snapshot data of this stopped sandbox, 14 days after it stopped. Resume and fork then fail with `409 snapshot_data_expired`. Null while the data is kept.
+     * @type {Date}
+     * @memberof Sandbox
+     */
+    dataExpiredAt?: Date | null;
     /**
      * `degraded` when the machine is alive but Boat cannot fully reach it (for example a firewall rule inside the sandbox blocks the tunnel). The sandbox keeps running.
      * @type {SandboxHealthEnum}
@@ -211,7 +218,7 @@ export interface Sandbox {
      */
     createdById?: string | null;
     /**
-     * What you may do with this sandbox. `owner`: you created it. `use`: a teammate's organization sandbox that never received their personal logins (`noEnv`, shared and restarted, or created on an environment that passes nothing), so you can open, run commands in, prompt, resume and stop it. `view`: a teammate's organization sandbox that still holds their personal logins, so you can see it and stop it until they share it (`POST /sandboxes/{sandboxId}/share`).
+     * What you may do with this sandbox. `owner`: you created it. `use`: a teammate's organization sandbox that is `shared` (see `visibility`), so you can open, run commands in, prompt, resume and stop it. `view`: a teammate's organization sandbox that is `private`, so you can see it and stop it until they share it (`POST /sandboxes/{sandboxId}/share`).
      * @type {SandboxAccessEnum}
      * @memberof Sandbox
      */
@@ -222,6 +229,18 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     holdsCreatorLogins?: boolean;
+    /**
+     * Organization sandboxes only; null for a personal sandbox. `shared`: every member can use it. It holds none of its creator's personal logins (`noEnv`, shared and restarted, or created on an environment that passes nothing) and its creator did not make it private. `private`: only its creator can use it. It holds their logins, or its creator made it private (`POST /sandboxes/{sandboxId}/unshare`, or the organization's `newSandboxesPrivate` default).
+     * @type {SandboxVisibilityEnum}
+     * @memberof Sandbox
+     */
+    visibility?: SandboxVisibilityEnum | null;
+    /**
+     *
+     * @type {SandboxCost}
+     * @memberof Sandbox
+     */
+    cost?: SandboxCost;
     /**
      * True once the sandbox is shared but not restarted yet. Its creator's logins are wiped at its next start, and the organization can use it from then on.
      * @type {boolean}
@@ -329,6 +348,14 @@ export declare const SandboxAccessEnum: {
     readonly View: 'view';
 };
 export type SandboxAccessEnum = typeof SandboxAccessEnum[keyof typeof SandboxAccessEnum];
+/**
+ * @export
+ */
+export declare const SandboxVisibilityEnum: {
+    readonly Shared: 'shared';
+    readonly Private: 'private';
+};
+export type SandboxVisibilityEnum = typeof SandboxVisibilityEnum[keyof typeof SandboxVisibilityEnum];
 /**
  * @export
  */

package/dist/esm/models/Sandbox.js

@@ -13,6 +13,7 @@
  */
 import { SandboxTeamFromJSON, SandboxTeamToJSON, } from './SandboxTeam';
 import { StopOperationFromJSON, StopOperationToJSON, } from './StopOperation';
+import { SandboxCostFromJSON, SandboxCostToJSON, } from './SandboxCost';
 import { SandboxHydrationFromJSON, SandboxHydrationToJSON, } from './SandboxHydration';
 /**
  * @export
@@ -61,6 +62,13 @@ export const SandboxAccessEnum = {
     Use: 'use',
     View: 'view'
 };
+/**
+ * @export
+ */
+export const SandboxVisibilityEnum = {
+    Shared: 'shared',
+    Private: 'private'
+};
 /**
  * @export
  */
@@ -108,6 +116,7 @@ export function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'name': json['name'],
         'state': json['state'],
         'error': json['error'] == null ? undefined : json['error'],
+        'dataExpiredAt': json['dataExpiredAt'] == null ? undefined : (new Date(json['dataExpiredAt'])),
         'health': json['health'] == null ? undefined : json['health'],
         'healthReason': json['healthReason'] == null ? undefined : json['healthReason'],
         'degradedSince': json['degradedSince'] == null ? undefined : (new Date(json['degradedSince'])),
@@ -138,6 +147,8 @@ export function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'createdById': json['createdById'] == null ? undefined : json['createdById'],
         'access': json['access'] == null ? undefined : json['access'],
         'holdsCreatorLogins': json['holdsCreatorLogins'] == null ? undefined : json['holdsCreatorLogins'],
+        'visibility': json['visibility'] == null ? undefined : json['visibility'],
+        'cost': json['cost'] == null ? undefined : SandboxCostFromJSON(json['cost']),
         'wipePendingUntilRestart': json['wipePendingUntilRestart'] == null ? undefined : json['wipePendingUntilRestart'],
         'subdomain': json['subdomain'] == null ? undefined : json['subdomain'],
         'lastSnapshotAttemptAt': json['lastSnapshotAttemptAt'] == null ? undefined : (new Date(json['lastSnapshotAttemptAt'])),
@@ -161,6 +172,7 @@ export function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'name': value['name'],
         'state': value['state'],
         'error': value['error'],
+        'dataExpiredAt': value['dataExpiredAt'] == null ? value['dataExpiredAt'] : value['dataExpiredAt'].toISOString(),
         'health': value['health'],
         'healthReason': value['healthReason'],
         'degradedSince': value['degradedSince'] == null ? value['degradedSince'] : value['degradedSince'].toISOString(),
@@ -191,6 +203,8 @@ export function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'createdById': value['createdById'],
         'access': value['access'],
         'holdsCreatorLogins': value['holdsCreatorLogins'],
+        'visibility': value['visibility'],
+        'cost': SandboxCostToJSON(value['cost']),
         'wipePendingUntilRestart': value['wipePendingUntilRestart'],
         'subdomain': value['subdomain'],
         'lastSnapshotAttemptAt': value['lastSnapshotAttemptAt'] == null ? value['lastSnapshotAttemptAt'] : value['lastSnapshotAttemptAt'].toISOString(),

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

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+/**
+ * Only with `include=cost` on `GET /sandboxes`. Machine time this sandbox used this calendar month (UTC), at list price. Same meter as `GET /sandboxes/{sandboxId}/usage`.
+ * @export
+ * @interface SandboxCost
+ */
+export interface SandboxCost {
+    /**
+     * The 1st of this month, 00:00 UTC.
+     * @type {Date}
+     * @memberof SandboxCost
+     */
+    since: Date;
+    /**
+     * Billable machine-seconds, size multiplier applied.
+     * @type {number}
+     * @memberof SandboxCost
+     */
+    seconds: number;
+    /**
+     * seconds / secondsPerDollar, at list price.
+     * @type {number}
+     * @memberof SandboxCost
+     */
+    dollars: number;
+}
+/**
+ * Check if a given object implements the SandboxCost interface.
+ */
+export declare function instanceOfSandboxCost(value: object): value is SandboxCost;
+export declare function SandboxCostFromJSON(json: any): SandboxCost;
+export declare function SandboxCostFromJSONTyped(json: any, ignoreDiscriminator: boolean): SandboxCost;
+export declare function SandboxCostToJSON(json: any): SandboxCost;
+export declare function SandboxCostToJSONTyped(value?: SandboxCost | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/SandboxCost.js

@@ -0,0 +1,51 @@
+/* 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.
+ */
+/**
+ * Check if a given object implements the SandboxCost interface.
+ */
+export function instanceOfSandboxCost(value) {
+    if (!('since' in value) || value['since'] === undefined)
+        return false;
+    if (!('seconds' in value) || value['seconds'] === undefined)
+        return false;
+    if (!('dollars' in value) || value['dollars'] === undefined)
+        return false;
+    return true;
+}
+export function SandboxCostFromJSON(json) {
+    return SandboxCostFromJSONTyped(json, false);
+}
+export function SandboxCostFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'since': (new Date(json['since'])),
+        'seconds': json['seconds'],
+        'dollars': json['dollars'],
+    };
+}
+export function SandboxCostToJSON(json) {
+    return SandboxCostToJSONTyped(json, false);
+}
+export function SandboxCostToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'since': value['since'].toISOString(),
+        'seconds': value['seconds'],
+        'dollars': value['dollars'],
+    };
+}

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

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+import type { Sandbox } from './Sandbox';
+/**
+ *
+ * @export
+ * @interface Unshare200Response
+ */
+export interface Unshare200Response {
+    /**
+     *
+     * @type {Sandbox}
+     * @memberof Unshare200Response
+     */
+    sandbox?: Sandbox;
+    /**
+     *
+     * @type {string}
+     * @memberof Unshare200Response
+     */
+    message?: string;
+}
+/**
+ * Check if a given object implements the Unshare200Response interface.
+ */
+export declare function instanceOfUnshare200Response(value: object): value is Unshare200Response;
+export declare function Unshare200ResponseFromJSON(json: any): Unshare200Response;
+export declare function Unshare200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): Unshare200Response;
+export declare function Unshare200ResponseToJSON(json: any): Unshare200Response;
+export declare function Unshare200ResponseToJSONTyped(value?: Unshare200Response | null, ignoreDiscriminator?: boolean): any;