@boatdev/sdk 1.9.9 → 1.10.0

package/.openapi-generator/FILES

@@ -122,6 +122,7 @@ docs/SandboxActionResponse.md
 docs/SandboxAiAccessResponse.md
 docs/SandboxAiUsage.md
 docs/SandboxAiUsageResponse.md
+docs/SandboxCost.md
 docs/SandboxEnvironment.md
 docs/SandboxEnvironmentListResponse.md
 docs/SandboxEnvironmentResponse.md
@@ -169,8 +170,11 @@ docs/TelemetrySetRequest.md
 docs/TelemetrySetResponse.md
 docs/TelemetryTestResult.md
 docs/UnknownEvent.md
+docs/Unshare200Response.md
 docs/UpdateAiProxyRequest.md
 docs/UpdateCredentialProfileRequest.md
+docs/UpdateOrganization200Response.md
+docs/UpdateOrganizationRequest.md
 docs/UpdateSandboxEnvironmentRequest.md
 docs/UpdateSandboxEnvironmentRequestRepositoriesInner.md
 docs/UpdateSandboxRequest.md
@@ -310,6 +314,7 @@ src/models/SandboxActionResponse.ts
 src/models/SandboxAiAccessResponse.ts
 src/models/SandboxAiUsage.ts
 src/models/SandboxAiUsageResponse.ts
+src/models/SandboxCost.ts
 src/models/SandboxEnvironment.ts
 src/models/SandboxEnvironmentListResponse.ts
 src/models/SandboxEnvironmentResponse.ts
@@ -357,8 +362,11 @@ src/models/TelemetrySetRequest.ts
 src/models/TelemetrySetResponse.ts
 src/models/TelemetryTestResult.ts
 src/models/UnknownEvent.ts
+src/models/Unshare200Response.ts
 src/models/UpdateAiProxyRequest.ts
 src/models/UpdateCredentialProfileRequest.ts
+src/models/UpdateOrganization200Response.ts
+src/models/UpdateOrganizationRequest.ts
 src/models/UpdateSandboxEnvironmentRequest.ts
 src/models/UpdateSandboxEnvironmentRequestRepositoriesInner.ts
 src/models/UpdateSandboxRequest.ts

package/dist/apis/BoatApi.d.ts

@@ -103,8 +103,11 @@ import { type StopRequest } from '../models/StopRequest';
 import { type TelemetryResponse } from '../models/TelemetryResponse';
 import { type TelemetrySetRequest } from '../models/TelemetrySetRequest';
 import { type TelemetrySetResponse } from '../models/TelemetrySetResponse';
+import { type Unshare200Response } from '../models/Unshare200Response';
 import { type UpdateAiProxyRequest } from '../models/UpdateAiProxyRequest';
 import { type UpdateCredentialProfileRequest } from '../models/UpdateCredentialProfileRequest';
+import { type UpdateOrganization200Response } from '../models/UpdateOrganization200Response';
+import { type UpdateOrganizationRequest } from '../models/UpdateOrganizationRequest';
 import { type UpdateSandboxEnvironmentRequest } from '../models/UpdateSandboxEnvironmentRequest';
 import { type UpdateSandboxRequest } from '../models/UpdateSandboxRequest';
 import { type UpgradeSandboxEnvironmentRequest } from '../models/UpgradeSandboxEnvironmentRequest';
@@ -401,6 +404,7 @@ export interface SandboxesRequest {
     cursor?: string | null;
     sort?: SandboxesSortEnum;
     state?: string;
+    include?: SandboxesIncludeEnum;
 }
 export interface SaveNamedSnapshotRequest {
     namedSnapshotSaveRequest: NamedSnapshotSaveRequest;
@@ -464,6 +468,9 @@ export interface SwitchCredentialAccountRequest {
     credential: CredentialId;
     account: string;
 }
+export interface UnshareRequest {
+    sandboxId: string;
+}
 export interface UpdateRequest {
     sandboxId: string;
     updateSandboxRequest: UpdateSandboxRequest;
@@ -485,6 +492,10 @@ export interface UpdateEnvironmentRequest {
     updateSandboxEnvironmentRequest: UpdateSandboxEnvironmentRequest;
     org?: string;
 }
+export interface UpdateOrganizationOperationRequest {
+    org: string;
+    updateOrganizationRequest: UpdateOrganizationRequest;
+}
 export interface UpdateSecretsRequest {
     secretsUpdateRequest: SecretsUpdateRequest;
 }
@@ -1141,12 +1152,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     getSandboxAiUsageRequestOpts(requestParameters: GetSandboxAiUsageRequest): Promise<runtime.RequestOpts>;
     /**
-     * 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
      */
     getSandboxAiUsageRaw(requestParameters: GetSandboxAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxAiUsageResponse>>;
     /**
-     * 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
      */
     getSandboxAiUsage(requestParameters: GetSandboxAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxAiUsageResponse>;
@@ -1463,12 +1474,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     recoverRequestOpts(requestParameters: RecoverRequest): Promise<runtime.RequestOpts>;
     /**
-     * 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
      */
     recoverRaw(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recover200Response>>;
     /**
-     * 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
      */
     recover(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recover200Response>;
@@ -1713,12 +1724,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     shareRequestOpts(requestParameters: ShareRequest): Promise<runtime.RequestOpts>;
     /**
-     * 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
      */
     shareRaw(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Share200Response>>;
     /**
-     * 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
      */
     share(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Share200Response>;
@@ -1792,6 +1803,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Switch a credential to another account
      */
     switchCredentialAccount(requestParameters: SwitchCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;
+    /**
+     * Creates request options for unshare without sending the request
+     */
+    unshareRequestOpts(requestParameters: UnshareRequest): Promise<runtime.RequestOpts>;
+    /**
+     * 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
+     */
+    unshareRaw(requestParameters: UnshareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unshare200Response>>;
+    /**
+     * 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
+     */
+    unshare(requestParameters: UnshareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unshare200Response>;
     /**
      * Creates request options for update without sending the request
      */
@@ -1860,6 +1885,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Update a sandbox environment
      */
     updateEnvironment(requestParameters: UpdateEnvironmentRequest | runtime.FlatBody<UpdateEnvironmentRequest, 'updateSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentResponse>;
+    /**
+     * Creates request options for updateOrganization without sending the request
+     */
+    updateOrganizationRequestOpts(input: UpdateOrganizationOperationRequest | runtime.FlatBody<UpdateOrganizationOperationRequest, 'updateOrganizationRequest'>): Promise<runtime.RequestOpts>;
+    /**
+     * 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
+     */
+    updateOrganizationRaw(requestParameters: UpdateOrganizationOperationRequest | runtime.FlatBody<UpdateOrganizationOperationRequest, 'updateOrganizationRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UpdateOrganization200Response>>;
+    /**
+     * 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
+     */
+    updateOrganization(requestParameters: UpdateOrganizationOperationRequest | runtime.FlatBody<UpdateOrganizationOperationRequest, 'updateOrganizationRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UpdateOrganization200Response>;
     /**
      * Creates request options for updateSecrets without sending the request
      */
@@ -2008,3 +2047,10 @@ export declare const SandboxesSortEnum: {
     readonly Desc: 'desc';
 };
 export type SandboxesSortEnum = typeof SandboxesSortEnum[keyof typeof SandboxesSortEnum];
+/**
+ * @export
+ */
+export declare const SandboxesIncludeEnum: {
+    readonly Cost: 'cost';
+};
+export type SandboxesIncludeEnum = typeof SandboxesIncludeEnum[keyof typeof SandboxesIncludeEnum];

package/dist/apis/BoatApi.js

@@ -46,7 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxesSortEnum = exports.ReposSortEnum = exports.ReadFileEncodingEnum = exports.ListSnapshotsSortEnum = exports.ListSandboxSnapshotsSortEnum = exports.EventsSortEnum = exports.DesktopOperationThemeEnum = exports.DesktopOperationVncEnum = exports.CommandLogsEncodingEnum = exports.CommandLogsStreamEnum = exports.BoatApi = void 0;
+exports.SandboxesIncludeEnum = exports.SandboxesSortEnum = exports.ReposSortEnum = exports.ReadFileEncodingEnum = exports.ListSnapshotsSortEnum = exports.ListSandboxSnapshotsSortEnum = exports.EventsSortEnum = exports.DesktopOperationThemeEnum = exports.DesktopOperationVncEnum = exports.CommandLogsEncodingEnum = exports.CommandLogsStreamEnum = exports.BoatApi = void 0;
 const runtime = __importStar(require("../runtime"));
 const AccountAiUsageResponse_1 = require("../models/AccountAiUsageResponse");
 const ActiveOrgResponse_1 = require("../models/ActiveOrgResponse");
@@ -140,8 +140,11 @@ const StopRequest_1 = require("../models/StopRequest");
 const TelemetryResponse_1 = require("../models/TelemetryResponse");
 const TelemetrySetRequest_1 = require("../models/TelemetrySetRequest");
 const TelemetrySetResponse_1 = require("../models/TelemetrySetResponse");
+const Unshare200Response_1 = require("../models/Unshare200Response");
 const UpdateAiProxyRequest_1 = require("../models/UpdateAiProxyRequest");
 const UpdateCredentialProfileRequest_1 = require("../models/UpdateCredentialProfileRequest");
+const UpdateOrganization200Response_1 = require("../models/UpdateOrganization200Response");
+const UpdateOrganizationRequest_1 = require("../models/UpdateOrganizationRequest");
 const UpdateSandboxEnvironmentRequest_1 = require("../models/UpdateSandboxEnvironmentRequest");
 const UpdateSandboxRequest_1 = require("../models/UpdateSandboxRequest");
 const UpgradeSandboxEnvironmentRequest_1 = require("../models/UpgradeSandboxEnvironmentRequest");
@@ -2275,7 +2278,7 @@ 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) {
@@ -2284,7 +2287,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SandboxAiUsageResponse_1.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) {
@@ -3275,7 +3278,7 @@ 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) {
@@ -3284,7 +3287,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, Recover200Response_1.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) {
@@ -3582,6 +3585,9 @@ 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']);
@@ -4116,7 +4122,7 @@ 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) {
@@ -4125,7 +4131,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, Share200Response_1.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) {
@@ -4372,6 +4378,48 @@ 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) => (0, Unshare200Response_1.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
      */
@@ -4611,6 +4659,54 @@ 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: (0, UpdateOrganizationRequest_1.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) => (0, UpdateOrganization200Response_1.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
      */
@@ -4916,3 +5012,9 @@ exports.SandboxesSortEnum = {
     Asc: 'asc',
     Desc: 'desc'
 };
+/**
+ * @export
+ */
+exports.SandboxesIncludeEnum = {
+    Cost: 'cost'
+};

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

@@ -103,8 +103,11 @@ import { type StopRequest } from '../models/StopRequest';
 import { type TelemetryResponse } from '../models/TelemetryResponse';
 import { type TelemetrySetRequest } from '../models/TelemetrySetRequest';
 import { type TelemetrySetResponse } from '../models/TelemetrySetResponse';
+import { type Unshare200Response } from '../models/Unshare200Response';
 import { type UpdateAiProxyRequest } from '../models/UpdateAiProxyRequest';
 import { type UpdateCredentialProfileRequest } from '../models/UpdateCredentialProfileRequest';
+import { type UpdateOrganization200Response } from '../models/UpdateOrganization200Response';
+import { type UpdateOrganizationRequest } from '../models/UpdateOrganizationRequest';
 import { type UpdateSandboxEnvironmentRequest } from '../models/UpdateSandboxEnvironmentRequest';
 import { type UpdateSandboxRequest } from '../models/UpdateSandboxRequest';
 import { type UpgradeSandboxEnvironmentRequest } from '../models/UpgradeSandboxEnvironmentRequest';
@@ -401,6 +404,7 @@ export interface SandboxesRequest {
     cursor?: string | null;
     sort?: SandboxesSortEnum;
     state?: string;
+    include?: SandboxesIncludeEnum;
 }
 export interface SaveNamedSnapshotRequest {
     namedSnapshotSaveRequest: NamedSnapshotSaveRequest;
@@ -464,6 +468,9 @@ export interface SwitchCredentialAccountRequest {
     credential: CredentialId;
     account: string;
 }
+export interface UnshareRequest {
+    sandboxId: string;
+}
 export interface UpdateRequest {
     sandboxId: string;
     updateSandboxRequest: UpdateSandboxRequest;
@@ -485,6 +492,10 @@ export interface UpdateEnvironmentRequest {
     updateSandboxEnvironmentRequest: UpdateSandboxEnvironmentRequest;
     org?: string;
 }
+export interface UpdateOrganizationOperationRequest {
+    org: string;
+    updateOrganizationRequest: UpdateOrganizationRequest;
+}
 export interface UpdateSecretsRequest {
     secretsUpdateRequest: SecretsUpdateRequest;
 }
@@ -1141,12 +1152,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     getSandboxAiUsageRequestOpts(requestParameters: GetSandboxAiUsageRequest): Promise<runtime.RequestOpts>;
     /**
-     * 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
      */
     getSandboxAiUsageRaw(requestParameters: GetSandboxAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxAiUsageResponse>>;
     /**
-     * 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
      */
     getSandboxAiUsage(requestParameters: GetSandboxAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxAiUsageResponse>;
@@ -1463,12 +1474,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     recoverRequestOpts(requestParameters: RecoverRequest): Promise<runtime.RequestOpts>;
     /**
-     * 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
      */
     recoverRaw(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recover200Response>>;
     /**
-     * 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
      */
     recover(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recover200Response>;
@@ -1713,12 +1724,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     shareRequestOpts(requestParameters: ShareRequest): Promise<runtime.RequestOpts>;
     /**
-     * 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
      */
     shareRaw(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Share200Response>>;
     /**
-     * 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
      */
     share(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Share200Response>;
@@ -1792,6 +1803,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Switch a credential to another account
      */
     switchCredentialAccount(requestParameters: SwitchCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse>;
+    /**
+     * Creates request options for unshare without sending the request
+     */
+    unshareRequestOpts(requestParameters: UnshareRequest): Promise<runtime.RequestOpts>;
+    /**
+     * 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
+     */
+    unshareRaw(requestParameters: UnshareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unshare200Response>>;
+    /**
+     * 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
+     */
+    unshare(requestParameters: UnshareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unshare200Response>;
     /**
      * Creates request options for update without sending the request
      */
@@ -1860,6 +1885,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Update a sandbox environment
      */
     updateEnvironment(requestParameters: UpdateEnvironmentRequest | runtime.FlatBody<UpdateEnvironmentRequest, 'updateSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentResponse>;
+    /**
+     * Creates request options for updateOrganization without sending the request
+     */
+    updateOrganizationRequestOpts(input: UpdateOrganizationOperationRequest | runtime.FlatBody<UpdateOrganizationOperationRequest, 'updateOrganizationRequest'>): Promise<runtime.RequestOpts>;
+    /**
+     * 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
+     */
+    updateOrganizationRaw(requestParameters: UpdateOrganizationOperationRequest | runtime.FlatBody<UpdateOrganizationOperationRequest, 'updateOrganizationRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UpdateOrganization200Response>>;
+    /**
+     * 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
+     */
+    updateOrganization(requestParameters: UpdateOrganizationOperationRequest | runtime.FlatBody<UpdateOrganizationOperationRequest, 'updateOrganizationRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UpdateOrganization200Response>;
     /**
      * Creates request options for updateSecrets without sending the request
      */
@@ -2008,3 +2047,10 @@ export declare const SandboxesSortEnum: {
     readonly Desc: 'desc';
 };
 export type SandboxesSortEnum = typeof SandboxesSortEnum[keyof typeof SandboxesSortEnum];
+/**
+ * @export
+ */
+export declare const SandboxesIncludeEnum: {
+    readonly Cost: 'cost';
+};
+export type SandboxesIncludeEnum = typeof SandboxesIncludeEnum[keyof typeof SandboxesIncludeEnum];