@boatdev/sdk 1.0.0 → 1.1.0

package/src/apis/BoatApi.ts

@@ -13,6 +13,16 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type ActiveOrgResponse,
+    ActiveOrgResponseFromJSON,
+    ActiveOrgResponseToJSON,
+} from '../models/ActiveOrgResponse';
+import {
+    type ActiveOrgUpdateRequest,
+    ActiveOrgUpdateRequestFromJSON,
+    ActiveOrgUpdateRequestToJSON,
+} from '../models/ActiveOrgUpdateRequest';
 import {
     type AddEnvironmentRepoRequest,
     AddEnvironmentRepoRequestFromJSON,
@@ -93,6 +103,11 @@ import {
     DataRetentionUpdateRequestFromJSON,
     DataRetentionUpdateRequestToJSON,
 } from '../models/DataRetentionUpdateRequest';
+import {
+    type DeletionOperationListResponse,
+    DeletionOperationListResponseFromJSON,
+    DeletionOperationListResponseToJSON,
+} from '../models/DeletionOperationListResponse';
 import {
     type DeletionOperationResponse,
     DeletionOperationResponseFromJSON,
@@ -188,6 +203,11 @@ import {
     NamedSnapshotSavingResponseFromJSON,
     NamedSnapshotSavingResponseToJSON,
 } from '../models/NamedSnapshotSavingResponse';
+import {
+    type OrgListResponse,
+    OrgListResponseFromJSON,
+    OrgListResponseToJSON,
+} from '../models/OrgListResponse';
 import {
     type PromptRequest,
     PromptRequestFromJSON,
@@ -450,6 +470,11 @@ export interface DeleteSandboxRequest {
     sandboxId: string;
 }
 
+export interface DeleteSandboxSnapshotsRequest {
+    sandboxId: string;
+    xAsciiConfirmDelete: string;
+}
+
 export interface DeleteSnapshotRequest {
     snapshotId: string;
     xAsciiConfirmDelete: string;
@@ -600,6 +625,10 @@ export interface SelectRepoRequest {
     repoSelectionRequest: RepoSelectionRequest;
 }
 
+export interface SetActiveOrganizationRequest {
+    activeOrgUpdateRequest: ActiveOrgUpdateRequest;
+}
+
 export interface SetEnvironmentSecretFileOperationRequest {
     environmentId: string;
     setEnvironmentSecretFileRequest: SetEnvironmentSecretFileRequest;
@@ -674,7 +703,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for addEnvironmentRepo without sending the request
      */
-    async addEnvironmentRepoRequestOpts(requestParameters: AddEnvironmentRepoOperationRequest): Promise<runtime.RequestOpts> {
+    async addEnvironmentRepoRequestOpts(input: AddEnvironmentRepoOperationRequest | runtime.FlatBody<AddEnvironmentRepoOperationRequest, 'addEnvironmentRepoRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<AddEnvironmentRepoOperationRequest>(input, 'addEnvironmentRepoRequest', ['environmentId'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -720,7 +750,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Adds a repository (or updates its base branch) by database id from the repository list. Mints a new immutable version.
      * Add a repository to an environment
      */
-    async addEnvironmentRepoRaw(requestParameters: AddEnvironmentRepoOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
+    async addEnvironmentRepoRaw(requestParameters: AddEnvironmentRepoOperationRequest | runtime.FlatBody<AddEnvironmentRepoOperationRequest, 'addEnvironmentRepoRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
         const requestOptions = await this.addEnvironmentRepoRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -731,7 +761,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Adds a repository (or updates its base branch) by database id from the repository list. Mints a new immutable version.
      * Add a repository to an environment
      */
-    async addEnvironmentRepo(requestParameters: AddEnvironmentRepoOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
+    async addEnvironmentRepo(requestParameters: AddEnvironmentRepoOperationRequest | runtime.FlatBody<AddEnvironmentRepoOperationRequest, 'addEnvironmentRepoRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
         const response = await this.addEnvironmentRepoRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -905,7 +935,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for command without sending the request
      */
-    async commandRequestOpts(requestParameters: CommandOperationRequest): Promise<runtime.RequestOpts> {
+    async commandRequestOpts(input: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<CommandOperationRequest>(input, 'commandRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -951,7 +982,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. Returns 409 boat_starting (retryable) while the sandbox is still provisioning -- wait until the sandbox state is ready before running commands. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
-    async commandRaw(requestParameters: CommandOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>> {
+    async commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>> {
         const requestOptions = await this.commandRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -962,7 +993,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. Returns 409 boat_starting (retryable) while the sandbox is still provisioning -- wait until the sandbox state is ready before running commands. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
-    async command(requestParameters: CommandOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response> {
+    async command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response> {
         const response = await this.commandRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -1090,7 +1121,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for create without sending the request
      */
-    async createRequestOpts(requestParameters: CreateRequest): Promise<runtime.RequestOpts> {
+    async createRequestOpts(input: CreateRequest | runtime.FlatBody<CreateRequest, 'createSandboxRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<CreateRequest>(input, 'createSandboxRequest', ['idempotencyKey', 'org', 'xBoatOrg'], ['org']);
         const queryParameters: any = {};
 
         if (requestParameters['org'] != null) {
@@ -1133,7 +1165,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Provision a new cloud computer. Store the returned `sandbox.id` with your product job/session record. Send an `Idempotency-Key` header to make this call safe to retry after a lost response without creating a second billable sandbox.
      * Create sandbox
      */
-    async createRaw(requestParameters: CreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateSandboxResponse>> {
+    async createRaw(requestParameters: CreateRequest | runtime.FlatBody<CreateRequest, 'createSandboxRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateSandboxResponse>> {
         const requestOptions = await this.createRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -1144,7 +1176,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Provision a new cloud computer. Store the returned `sandbox.id` with your product job/session record. Send an `Idempotency-Key` header to make this call safe to retry after a lost response without creating a second billable sandbox.
      * Create sandbox
      */
-    async create(requestParameters: CreateRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateSandboxResponse> {
+    async create(requestParameters: CreateRequest | runtime.FlatBody<CreateRequest, 'createSandboxRequest'> = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateSandboxResponse> {
         const response = await this.createRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -1152,7 +1184,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for createEnvironment without sending the request
      */
-    async createEnvironmentRequestOpts(requestParameters: CreateEnvironmentRequest): Promise<runtime.RequestOpts> {
+    async createEnvironmentRequestOpts(input: CreateEnvironmentRequest | runtime.FlatBody<CreateEnvironmentRequest, 'createSandboxEnvironmentRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<CreateEnvironmentRequest>(input, 'createSandboxEnvironmentRequest', [], []);
         if (requestParameters['createSandboxEnvironmentRequest'] == null) {
             throw new runtime.RequiredError(
                 'createSandboxEnvironmentRequest',
@@ -1190,7 +1223,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Create a new named environment. It starts on version 1 with all fine-grained flags on and `safeForThirdParties` off.
      * Create a sandbox environment
      */
-    async createEnvironmentRaw(requestParameters: CreateEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentListResponse>> {
+    async createEnvironmentRaw(requestParameters: CreateEnvironmentRequest | runtime.FlatBody<CreateEnvironmentRequest, 'createSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentListResponse>> {
         const requestOptions = await this.createEnvironmentRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -1201,7 +1234,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Create a new named environment. It starts on version 1 with all fine-grained flags on and `safeForThirdParties` off.
      * Create a sandbox environment
      */
-    async createEnvironment(requestParameters: CreateEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentListResponse> {
+    async createEnvironment(requestParameters: CreateEnvironmentRequest | runtime.FlatBody<CreateEnvironmentRequest, 'createSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentListResponse> {
         const response = await this.createEnvironmentRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -1209,7 +1242,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for createScopedApiKey without sending the request
      */
-    async createScopedApiKeyRequestOpts(requestParameters: CreateScopedApiKeyOperationRequest): Promise<runtime.RequestOpts> {
+    async createScopedApiKeyRequestOpts(input: CreateScopedApiKeyOperationRequest | runtime.FlatBody<CreateScopedApiKeyOperationRequest, 'createScopedApiKeyRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<CreateScopedApiKeyOperationRequest>(input, 'createScopedApiKeyRequest', [], []);
         if (requestParameters['createScopedApiKeyRequest'] == null) {
             throw new runtime.RequiredError(
                 'createScopedApiKeyRequest',
@@ -1247,7 +1281,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates a scoped, expiring API key. Requires a dashboard/CLI session or an admin-scoped token. The secret is returned once. This dedicated path returns a typed 503 until scoped credential creation is activated.
      * Create a scoped API key
      */
-    async createScopedApiKeyRaw(requestParameters: CreateScopedApiKeyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiKeySecretResponse>> {
+    async createScopedApiKeyRaw(requestParameters: CreateScopedApiKeyOperationRequest | runtime.FlatBody<CreateScopedApiKeyOperationRequest, 'createScopedApiKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ApiKeySecretResponse>> {
         const requestOptions = await this.createScopedApiKeyRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -1258,7 +1292,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates a scoped, expiring API key. Requires a dashboard/CLI session or an admin-scoped token. The secret is returned once. This dedicated path returns a typed 503 until scoped credential creation is activated.
      * Create a scoped API key
      */
-    async createScopedApiKey(requestParameters: CreateScopedApiKeyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiKeySecretResponse> {
+    async createScopedApiKey(requestParameters: CreateScopedApiKeyOperationRequest | runtime.FlatBody<CreateScopedApiKeyOperationRequest, 'createScopedApiKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ApiKeySecretResponse> {
         const response = await this.createScopedApiKeyRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -1266,7 +1300,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for createWebhook without sending the request
      */
-    async createWebhookRequestOpts(requestParameters: CreateWebhookRequest): Promise<runtime.RequestOpts> {
+    async createWebhookRequestOpts(input: CreateWebhookRequest | runtime.FlatBody<CreateWebhookRequest, 'webhookCreateRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<CreateWebhookRequest>(input, 'webhookCreateRequest', [], []);
         if (requestParameters['webhookCreateRequest'] == null) {
             throw new runtime.RequiredError(
                 'webhookCreateRequest',
@@ -1304,7 +1339,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Registers an account-wide endpoint for sandbox lifecycle events. The endpoint must use HTTPS on port 443 and resolve only to public addresses. Redirects are not followed during delivery.  The signing secret is returned only in this response. An account can register at most 10 unique endpoint URLs. 
      * Create webhook
      */
-    async createWebhookRaw(requestParameters: CreateWebhookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WebhookSecretResponse>> {
+    async createWebhookRaw(requestParameters: CreateWebhookRequest | runtime.FlatBody<CreateWebhookRequest, 'webhookCreateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WebhookSecretResponse>> {
         const requestOptions = await this.createWebhookRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -1315,7 +1350,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Registers an account-wide endpoint for sandbox lifecycle events. The endpoint must use HTTPS on port 443 and resolve only to public addresses. Redirects are not followed during delivery.  The signing secret is returned only in this response. An account can register at most 10 unique endpoint URLs. 
      * Create webhook
      */
-    async createWebhook(requestParameters: CreateWebhookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WebhookSecretResponse> {
+    async createWebhook(requestParameters: CreateWebhookRequest | runtime.FlatBody<CreateWebhookRequest, 'webhookCreateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WebhookSecretResponse> {
         const response = await this.createWebhookRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -1688,6 +1723,72 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for deleteSandboxSnapshots without sending the request
+     */
+    async deleteSandboxSnapshotsRequestOpts(requestParameters: DeleteSandboxSnapshotsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling deleteSandboxSnapshots().'
+            );
+        }
+
+        if (requestParameters['xAsciiConfirmDelete'] == null) {
+            throw new runtime.RequiredError(
+                'xAsciiConfirmDelete',
+                'Required parameter "xAsciiConfirmDelete" was null or undefined when calling deleteSandboxSnapshots().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xAsciiConfirmDelete'] != null) {
+            headerParameters['X-Ascii-Confirm-Delete'] = String(requestParameters['xAsciiConfirmDelete']);
+        }
+
+        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}/snapshots`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Accept irreversible deletion of every unpinned snapshot of this sandbox. The sandbox itself and its named snapshots stay. Snapshots disappear from lists, restores and forks immediately; their stored data is purged in the background. Set `X-Ascii-Confirm-Delete` to the sandbox id.
+     * Permanently delete all snapshots of a sandbox
+     */
+    async deleteSandboxSnapshotsRaw(requestParameters: DeleteSandboxSnapshotsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeletionOperationListResponse>> {
+        const requestOptions = await this.deleteSandboxSnapshotsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => DeletionOperationListResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Accept irreversible deletion of every unpinned snapshot of this sandbox. The sandbox itself and its named snapshots stay. Snapshots disappear from lists, restores and forks immediately; their stored data is purged in the background. Set `X-Ascii-Confirm-Delete` to the sandbox id.
+     * Permanently delete all snapshots of a sandbox
+     */
+    async deleteSandboxSnapshots(requestParameters: DeleteSandboxSnapshotsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeletionOperationListResponse> {
+        const response = await this.deleteSandboxSnapshotsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for deleteSnapshot without sending the request
      */
@@ -1735,7 +1836,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Accept irreversible background deletion of an unpinned snapshot owned by the authenticated account. Snapshots required by another incremental snapshot or active restore return `409`. Poll the returned operation until `completed`.
+     * Accept irreversible deletion of an unpinned snapshot owned by the authenticated account. Any such snapshot is accepted: it disappears from lists, restores and forks immediately, and its stored data is purged in the background once nothing still reads it (see the operation\'s `stage`). `409` only means `X-Ascii-Confirm-Delete` is missing or wrong.
      * Permanently delete snapshot data
      */
     async deleteSnapshotRaw(requestParameters: DeleteSnapshotRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeletionOperationResponse>> {
@@ -1746,7 +1847,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Accept irreversible background deletion of an unpinned snapshot owned by the authenticated account. Snapshots required by another incremental snapshot or active restore return `409`. Poll the returned operation until `completed`.
+     * Accept irreversible deletion of an unpinned snapshot owned by the authenticated account. Any such snapshot is accepted: it disappears from lists, restores and forks immediately, and its stored data is purged in the background once nothing still reads it (see the operation\'s `stage`). `409` only means `X-Ascii-Confirm-Delete` is missing or wrong.
      * Permanently delete snapshot data
      */
     async deleteSnapshot(requestParameters: DeleteSnapshotRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeletionOperationResponse> {
@@ -1812,7 +1913,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for desktop without sending the request
      */
-    async desktopRequestOpts(requestParameters: DesktopOperationRequest): Promise<runtime.RequestOpts> {
+    async desktopRequestOpts(input: DesktopOperationRequest | runtime.FlatBody<DesktopOperationRequest, 'desktopRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<DesktopOperationRequest>(input, 'desktopRequest', ['sandboxId', 'vnc', 'theme'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -1859,7 +1961,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Create or fetch a secret-bearing desktop/noVNC URL for live computer-use visibility. Use `?vnc=1` for noVNC; a `provisioning: true` response means poll again.
      * Get desktop streaming URL
      */
-    async desktopRaw(requestParameters: DesktopOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DesktopResponse>> {
+    async desktopRaw(requestParameters: DesktopOperationRequest | runtime.FlatBody<DesktopOperationRequest, 'desktopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DesktopResponse>> {
         const requestOptions = await this.desktopRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -1870,7 +1972,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Create or fetch a secret-bearing desktop/noVNC URL for live computer-use visibility. Use `?vnc=1` for noVNC; a `provisioning: true` response means poll again.
      * Get desktop streaming URL
      */
-    async desktop(requestParameters: DesktopOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DesktopResponse> {
+    async desktop(requestParameters: DesktopOperationRequest | runtime.FlatBody<DesktopOperationRequest, 'desktopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DesktopResponse> {
         const response = await this.desktopRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -2000,7 +2102,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for fork without sending the request
      */
-    async forkRequestOpts(requestParameters: ForkOperationRequest): Promise<runtime.RequestOpts> {
+    async forkRequestOpts(input: ForkOperationRequest | runtime.FlatBody<ForkOperationRequest, 'forkRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<ForkOperationRequest>(input, 'forkRequest', ['sandboxId', 'idempotencyKey'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -2043,7 +2146,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Provision a new sandbox from an existing one. Send an `Idempotency-Key` header to make this call safe to retry after a lost response without creating a second billable fork.
      * Fork sandbox
      */
-    async forkRaw(requestParameters: ForkOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
+    async forkRaw(requestParameters: ForkOperationRequest | runtime.FlatBody<ForkOperationRequest, 'forkRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
         const requestOptions = await this.forkRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -2054,7 +2157,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Provision a new sandbox from an existing one. Send an `Idempotency-Key` header to make this call safe to retry after a lost response without creating a second billable fork.
      * Fork sandbox
      */
-    async fork(requestParameters: ForkOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
+    async fork(requestParameters: ForkOperationRequest | runtime.FlatBody<ForkOperationRequest, 'forkRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
         const response = await this.forkRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -2551,7 +2654,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for hostPort without sending the request
      */
-    async hostPortRequestOpts(requestParameters: HostPortOperationRequest): Promise<runtime.RequestOpts> {
+    async hostPortRequestOpts(input: HostPortOperationRequest | runtime.FlatBody<HostPortOperationRequest, 'hostPortRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<HostPortOperationRequest>(input, 'hostPortRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -2597,7 +2701,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Registers a stable `https://<sandbox-subdomain>-<port>.on.boat.dev` route for a port inside the sandbox and opens the sandbox firewall for it. Idempotent: calling it again for the same sandbox and port returns the same URL and token.
      * Expose a sandbox port on a public HTTPS URL
      */
-    async hostPortRaw(requestParameters: HostPortOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HostPortResponse>> {
+    async hostPortRaw(requestParameters: HostPortOperationRequest | runtime.FlatBody<HostPortOperationRequest, 'hostPortRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HostPortResponse>> {
         const requestOptions = await this.hostPortRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -2608,7 +2712,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Registers a stable `https://<sandbox-subdomain>-<port>.on.boat.dev` route for a port inside the sandbox and opens the sandbox firewall for it. Idempotent: calling it again for the same sandbox and port returns the same URL and token.
      * Expose a sandbox port on a public HTTPS URL
      */
-    async hostPort(requestParameters: HostPortOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<HostPortResponse> {
+    async hostPort(requestParameters: HostPortOperationRequest | runtime.FlatBody<HostPortOperationRequest, 'hostPortRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<HostPortResponse> {
         const response = await this.hostPortRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -2712,7 +2816,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Check remaining machine starts, compute time, credits, access readiness, and concurrent-sandbox capacity for the authenticated account. Pass `org` / `X-Boat-Org` (or `teamId`) to read a team wallet you belong to.
+     * Check remaining machine starts, compute time, credits, access readiness, and concurrent-sandbox capacity for the wallet a create would bill: the `org` / `X-Boat-Org` you pass (id or name), else the account\'s active wallet, else personal. The response carries `teamId` when an organization wallet was read.
      * Get Boat limits
      */
     async limitsRaw(requestParameters: LimitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LimitsResponse>> {
@@ -2723,7 +2827,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Check remaining machine starts, compute time, credits, access readiness, and concurrent-sandbox capacity for the authenticated account. Pass `org` / `X-Boat-Org` (or `teamId`) to read a team wallet you belong to.
+     * Check remaining machine starts, compute time, credits, access readiness, and concurrent-sandbox capacity for the wallet a create would bill: the `org` / `X-Boat-Org` you pass (id or name), else the account\'s active wallet, else personal. The response carries `teamId` when an organization wallet was read.
      * Get Boat limits
      */
     async limits(requestParameters: LimitsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LimitsResponse> {
@@ -2778,6 +2882,53 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for listOrganizations without sending the request
+     */
+    async listOrganizationsRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * The wallets this account can bill: your personal account first, then every organization you belong to, each with its id and name. Either spelling works wherever an org is passed (`org`, `X-Boat-Org`, `teamId`). `active` marks the wallet new sandboxes bill when a request names none; change it with `PATCH /orgs/active`.
+     * List organizations
+     */
+    async listOrganizationsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OrgListResponse>> {
+        const requestOptions = await this.listOrganizationsRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OrgListResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * The wallets this account can bill: your personal account first, then every organization you belong to, each with its id and name. Either spelling works wherever an org is passed (`org`, `X-Boat-Org`, `teamId`). `active` marks the wallet new sandboxes bill when a request names none; change it with `PATCH /orgs/active`.
+     * List organizations
+     */
+    async listOrganizations(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OrgListResponse> {
+        const response = await this.listOrganizationsRaw(initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for listSandboxSnapshots without sending the request
      */
@@ -3001,7 +3152,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for prompt without sending the request
      */
-    async promptRequestOpts(requestParameters: PromptOperationRequest): Promise<runtime.RequestOpts> {
+    async promptRequestOpts(input: PromptOperationRequest | runtime.FlatBody<PromptOperationRequest, 'promptRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<PromptOperationRequest>(input, 'promptRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -3047,7 +3199,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Queue a natural-language work item for an agent harness (Codex, Claude Code, pi, OpenCode, or Prime Agent) inside the sandbox. Observe progress with `GET /sandboxes/{sandboxId}/events`.  A Sandbox runs many conversations in parallel. Set `new: true` to start a fresh one, `conversationId` to continue a specific one, or omit both to continue the most-recently-active conversation; the response returns the `conversationId`. See [Integrated agents](/integrated-agents).
      * Prompt Sandbox
      */
-    async promptRaw(requestParameters: PromptOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PromptResponse>> {
+    async promptRaw(requestParameters: PromptOperationRequest | runtime.FlatBody<PromptOperationRequest, 'promptRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PromptResponse>> {
         const requestOptions = await this.promptRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3058,7 +3210,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Queue a natural-language work item for an agent harness (Codex, Claude Code, pi, OpenCode, or Prime Agent) inside the sandbox. Observe progress with `GET /sandboxes/{sandboxId}/events`.  A Sandbox runs many conversations in parallel. Set `new: true` to start a fresh one, `conversationId` to continue a specific one, or omit both to continue the most-recently-active conversation; the response returns the `conversationId`. See [Integrated agents](/integrated-agents).
      * Prompt Sandbox
      */
-    async prompt(requestParameters: PromptOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PromptResponse> {
+    async prompt(requestParameters: PromptOperationRequest | runtime.FlatBody<PromptOperationRequest, 'promptRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PromptResponse> {
         const response = await this.promptRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3268,7 +3420,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for resume without sending the request
      */
-    async resumeRequestOpts(requestParameters: ResumeOperationRequest): Promise<runtime.RequestOpts> {
+    async resumeRequestOpts(input: ResumeOperationRequest | runtime.FlatBody<ResumeOperationRequest, 'resumeRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<ResumeOperationRequest>(input, 'resumeRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -3306,7 +3459,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Resume sandbox
      */
-    async resumeRaw(requestParameters: ResumeOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
+    async resumeRaw(requestParameters: ResumeOperationRequest | runtime.FlatBody<ResumeOperationRequest, 'resumeRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
         const requestOptions = await this.resumeRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3316,7 +3469,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Resume sandbox
      */
-    async resume(requestParameters: ResumeOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
+    async resume(requestParameters: ResumeOperationRequest | runtime.FlatBody<ResumeOperationRequest, 'resumeRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
         const response = await this.resumeRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3550,7 +3703,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for saveNamedSnapshot without sending the request
      */
-    async saveNamedSnapshotRequestOpts(requestParameters: SaveNamedSnapshotRequest): Promise<runtime.RequestOpts> {
+    async saveNamedSnapshotRequestOpts(input: SaveNamedSnapshotRequest | runtime.FlatBody<SaveNamedSnapshotRequest, 'namedSnapshotSaveRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SaveNamedSnapshotRequest>(input, 'namedSnapshotSaveRequest', [], []);
         if (requestParameters['namedSnapshotSaveRequest'] == null) {
             throw new runtime.RequiredError(
                 'namedSnapshotSaveRequest',
@@ -3588,7 +3742,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Freeze a sandbox\'s current state under a name (`boat snapshot <id> <name>` in the CLI). Answers `202` immediately with the snapshot in `saving`; a running sandbox takes a fresh capture first, which can run minutes. Poll `GET /named-snapshots/{name}` until the status settles at `ready` or `failed`. Reusing one of your existing names replaces that snapshot\'s artifact once the new save is ready.
      * Save a named snapshot
      */
-    async saveNamedSnapshotRaw(requestParameters: SaveNamedSnapshotRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<NamedSnapshotSavingResponse>> {
+    async saveNamedSnapshotRaw(requestParameters: SaveNamedSnapshotRequest | runtime.FlatBody<SaveNamedSnapshotRequest, 'namedSnapshotSaveRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<NamedSnapshotSavingResponse>> {
         const requestOptions = await this.saveNamedSnapshotRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3599,7 +3753,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Freeze a sandbox\'s current state under a name (`boat snapshot <id> <name>` in the CLI). Answers `202` immediately with the snapshot in `saving`; a running sandbox takes a fresh capture first, which can run minutes. Poll `GET /named-snapshots/{name}` until the status settles at `ready` or `failed`. Reusing one of your existing names replaces that snapshot\'s artifact once the new save is ready.
      * Save a named snapshot
      */
-    async saveNamedSnapshot(requestParameters: SaveNamedSnapshotRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NamedSnapshotSavingResponse> {
+    async saveNamedSnapshot(requestParameters: SaveNamedSnapshotRequest | runtime.FlatBody<SaveNamedSnapshotRequest, 'namedSnapshotSaveRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<NamedSnapshotSavingResponse> {
         const response = await this.saveNamedSnapshotRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3654,7 +3808,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for selectRepo without sending the request
      */
-    async selectRepoRequestOpts(requestParameters: SelectRepoRequest): Promise<runtime.RequestOpts> {
+    async selectRepoRequestOpts(input: SelectRepoRequest | runtime.FlatBody<SelectRepoRequest, 'repoSelectionRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SelectRepoRequest>(input, 'repoSelectionRequest', [], []);
         if (requestParameters['repoSelectionRequest'] == null) {
             throw new runtime.RequiredError(
                 'repoSelectionRequest',
@@ -3692,7 +3847,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Idempotently selects one repository for the sandbox environment. Use `databaseId` from `GET /repos` as `repositoryId`; selecting an already-selected repository updates its `baseBranch`.
      * Select repository for sandboxes
      */
-    async selectRepoRaw(requestParameters: SelectRepoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RepoSelectionResponse>> {
+    async selectRepoRaw(requestParameters: SelectRepoRequest | runtime.FlatBody<SelectRepoRequest, 'repoSelectionRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RepoSelectionResponse>> {
         const requestOptions = await this.selectRepoRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3703,15 +3858,74 @@ export class BoatApi extends runtime.BaseAPI {
      * Idempotently selects one repository for the sandbox environment. Use `databaseId` from `GET /repos` as `repositoryId`; selecting an already-selected repository updates its `baseBranch`.
      * Select repository for sandboxes
      */
-    async selectRepo(requestParameters: SelectRepoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RepoSelectionResponse> {
+    async selectRepo(requestParameters: SelectRepoRequest | runtime.FlatBody<SelectRepoRequest, 'repoSelectionRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RepoSelectionResponse> {
         const response = await this.selectRepoRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
+    /**
+     * Creates request options for setActiveOrganization without sending the request
+     */
+    async setActiveOrganizationRequestOpts(input: SetActiveOrganizationRequest | runtime.FlatBody<SetActiveOrganizationRequest, 'activeOrgUpdateRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetActiveOrganizationRequest>(input, 'activeOrgUpdateRequest', [], []);
+        if (requestParameters['activeOrgUpdateRequest'] == null) {
+            throw new runtime.RequiredError(
+                'activeOrgUpdateRequest',
+                'Required parameter "activeOrgUpdateRequest" was null or undefined when calling setActiveOrganization().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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/active`;
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ActiveOrgUpdateRequestToJSON(requestParameters['activeOrgUpdateRequest']),
+        };
+    }
+
+    /**
+     * Set the wallet new sandboxes bill when a request names none, for this account on every client: the API, the CLI (`boat org switch` sets the same value) and the dashboard. Pass an organization id or name you belong to, or `personal` (or `null`) for your own account. `GET /limits` follows it. Sandboxes already running keep the wallet they were created with; leaving or deleting the organization resets the account to personal.
+     * Set the active organization
+     */
+    async setActiveOrganizationRaw(requestParameters: SetActiveOrganizationRequest | runtime.FlatBody<SetActiveOrganizationRequest, 'activeOrgUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ActiveOrgResponse>> {
+        const requestOptions = await this.setActiveOrganizationRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ActiveOrgResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Set the wallet new sandboxes bill when a request names none, for this account on every client: the API, the CLI (`boat org switch` sets the same value) and the dashboard. Pass an organization id or name you belong to, or `personal` (or `null`) for your own account. `GET /limits` follows it. Sandboxes already running keep the wallet they were created with; leaving or deleting the organization resets the account to personal.
+     * Set the active organization
+     */
+    async setActiveOrganization(requestParameters: SetActiveOrganizationRequest | runtime.FlatBody<SetActiveOrganizationRequest, 'activeOrgUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ActiveOrgResponse> {
+        const response = await this.setActiveOrganizationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for setEnvironmentSecretFile without sending the request
      */
-    async setEnvironmentSecretFileRequestOpts(requestParameters: SetEnvironmentSecretFileOperationRequest): Promise<runtime.RequestOpts> {
+    async setEnvironmentSecretFileRequestOpts(input: SetEnvironmentSecretFileOperationRequest | runtime.FlatBody<SetEnvironmentSecretFileOperationRequest, 'setEnvironmentSecretFileRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetEnvironmentSecretFileOperationRequest>(input, 'setEnvironmentSecretFileRequest', ['environmentId'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -3757,7 +3971,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Adds or replaces a single secret file by path. Mints a new immutable version.
      * Write one secret file
      */
-    async setEnvironmentSecretFileRaw(requestParameters: SetEnvironmentSecretFileOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
+    async setEnvironmentSecretFileRaw(requestParameters: SetEnvironmentSecretFileOperationRequest | runtime.FlatBody<SetEnvironmentSecretFileOperationRequest, 'setEnvironmentSecretFileRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
         const requestOptions = await this.setEnvironmentSecretFileRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3768,7 +3982,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Adds or replaces a single secret file by path. Mints a new immutable version.
      * Write one secret file
      */
-    async setEnvironmentSecretFile(requestParameters: SetEnvironmentSecretFileOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
+    async setEnvironmentSecretFile(requestParameters: SetEnvironmentSecretFileOperationRequest | runtime.FlatBody<SetEnvironmentSecretFileOperationRequest, 'setEnvironmentSecretFileRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
         const response = await this.setEnvironmentSecretFileRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3776,7 +3990,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for setEnvironmentVar without sending the request
      */
-    async setEnvironmentVarRequestOpts(requestParameters: SetEnvironmentVarOperationRequest): Promise<runtime.RequestOpts> {
+    async setEnvironmentVarRequestOpts(input: SetEnvironmentVarOperationRequest | runtime.FlatBody<SetEnvironmentVarOperationRequest, 'setEnvironmentVarRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetEnvironmentVarOperationRequest>(input, 'setEnvironmentVarRequest', ['environmentId', 'key'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -3830,7 +4045,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Sets or replaces a single variable without reading or rewriting the rest. Mints a new immutable version.
      * Set one environment variable
      */
-    async setEnvironmentVarRaw(requestParameters: SetEnvironmentVarOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
+    async setEnvironmentVarRaw(requestParameters: SetEnvironmentVarOperationRequest | runtime.FlatBody<SetEnvironmentVarOperationRequest, 'setEnvironmentVarRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
         const requestOptions = await this.setEnvironmentVarRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3841,7 +4056,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Sets or replaces a single variable without reading or rewriting the rest. Mints a new immutable version.
      * Set one environment variable
      */
-    async setEnvironmentVar(requestParameters: SetEnvironmentVarOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
+    async setEnvironmentVar(requestParameters: SetEnvironmentVarOperationRequest | runtime.FlatBody<SetEnvironmentVarOperationRequest, 'setEnvironmentVarRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
         const response = await this.setEnvironmentVarRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3849,7 +4064,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for sshKey without sending the request
      */
-    async sshKeyRequestOpts(requestParameters: SshKeyOperationRequest): Promise<runtime.RequestOpts> {
+    async sshKeyRequestOpts(input: SshKeyOperationRequest | runtime.FlatBody<SshKeyOperationRequest, 'sshKeyRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SshKeyOperationRequest>(input, 'sshKeyRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -3895,7 +4111,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Adds an OpenSSH public key to the running sandbox so the caller can SSH as user `user`. The response carries `machineIp`, which is the host to connect to on port 22.  This is also how you reach your own machine from inside a sandbox without the CLI: authorize the key, then open a reverse tunnel with stock OpenSSH, and a port on your machine answers at `127.0.0.1:<port>` inside the sandbox for as long as the ssh process runs.  ```bash ssh -o ExitOnForwardFailure=yes -i ~/.ssh/id_ed25519 -N -R 7777:127.0.0.1:7777 user@<machineIp> ```  `boat forward <id> --reverse --local 7777` is the same tunnel with the key handling and redial done for you. 
      * Configure sandbox SSH key
      */
-    async sshKeyRaw(requestParameters: SshKeyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SshKeyResponse>> {
+    async sshKeyRaw(requestParameters: SshKeyOperationRequest | runtime.FlatBody<SshKeyOperationRequest, 'sshKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SshKeyResponse>> {
         const requestOptions = await this.sshKeyRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3906,7 +4122,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Adds an OpenSSH public key to the running sandbox so the caller can SSH as user `user`. The response carries `machineIp`, which is the host to connect to on port 22.  This is also how you reach your own machine from inside a sandbox without the CLI: authorize the key, then open a reverse tunnel with stock OpenSSH, and a port on your machine answers at `127.0.0.1:<port>` inside the sandbox for as long as the ssh process runs.  ```bash ssh -o ExitOnForwardFailure=yes -i ~/.ssh/id_ed25519 -N -R 7777:127.0.0.1:7777 user@<machineIp> ```  `boat forward <id> --reverse --local 7777` is the same tunnel with the key handling and redial done for you. 
      * Configure sandbox SSH key
      */
-    async sshKey(requestParameters: SshKeyOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SshKeyResponse> {
+    async sshKey(requestParameters: SshKeyOperationRequest | runtime.FlatBody<SshKeyOperationRequest, 'sshKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SshKeyResponse> {
         const response = await this.sshKeyRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3914,7 +4130,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for steer without sending the request
      */
-    async steerRequestOpts(requestParameters: SteerOperationRequest): Promise<runtime.RequestOpts> {
+    async steerRequestOpts(input: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SteerOperationRequest>(input, 'steerRequest', ['sandboxId', 'conversation'], ['conversation']);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -3964,7 +4181,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
-    async steerRaw(requestParameters: SteerOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SteerResponse>> {
+    async steerRaw(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SteerResponse>> {
         const requestOptions = await this.steerRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -3975,7 +4192,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
-    async steer(requestParameters: SteerOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SteerResponse> {
+    async steer(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SteerResponse> {
         const response = await this.steerRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -3983,7 +4200,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for stop without sending the request
      */
-    async stopRequestOpts(requestParameters: StopOperationRequest): Promise<runtime.RequestOpts> {
+    async stopRequestOpts(input: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<StopOperationRequest>(input, 'stopRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -4022,7 +4240,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed. 
      * Stop and archive sandbox
      */
-    async stopRaw(requestParameters: StopOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
+    async stopRaw(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>> {
         const requestOptions = await this.stopRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4033,7 +4251,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed. 
      * Stop and archive sandbox
      */
-    async stop(requestParameters: StopOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
+    async stop(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse> {
         const response = await this.stopRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4041,7 +4259,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for update without sending the request
      */
-    async updateRequestOpts(requestParameters: UpdateRequest): Promise<runtime.RequestOpts> {
+    async updateRequestOpts(input: UpdateRequest | runtime.FlatBody<UpdateRequest, 'updateSandboxRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateRequest>(input, 'updateSandboxRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -4086,7 +4305,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Update sandbox
      */
-    async updateRaw(requestParameters: UpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxInfoResponse>> {
+    async updateRaw(requestParameters: UpdateRequest | runtime.FlatBody<UpdateRequest, 'updateSandboxRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxInfoResponse>> {
         const requestOptions = await this.updateRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4096,7 +4315,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Update sandbox
      */
-    async update(requestParameters: UpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxInfoResponse> {
+    async update(requestParameters: UpdateRequest | runtime.FlatBody<UpdateRequest, 'updateSandboxRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxInfoResponse> {
         const response = await this.updateRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4104,7 +4323,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for updateDataRetention without sending the request
      */
-    async updateDataRetentionRequestOpts(requestParameters: UpdateDataRetentionRequest): Promise<runtime.RequestOpts> {
+    async updateDataRetentionRequestOpts(input: UpdateDataRetentionRequest | runtime.FlatBody<UpdateDataRetentionRequest, 'dataRetentionUpdateRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateDataRetentionRequest>(input, 'dataRetentionUpdateRequest', [], []);
         if (requestParameters['dataRetentionUpdateRequest'] == null) {
             throw new runtime.RequiredError(
                 'dataRetentionUpdateRequest',
@@ -4142,7 +4362,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Requires an interactive sandbox session; API keys and legacy permanent tokens are refused. Enabling requires the exact confirmation phrase `delete archived sandbox data`. Disabling affects future archives only and cannot cancel deletion operations already accepted.
      * Update account data-retention policy
      */
-    async updateDataRetentionRaw(requestParameters: UpdateDataRetentionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DataRetentionPolicyResponse>> {
+    async updateDataRetentionRaw(requestParameters: UpdateDataRetentionRequest | runtime.FlatBody<UpdateDataRetentionRequest, 'dataRetentionUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DataRetentionPolicyResponse>> {
         const requestOptions = await this.updateDataRetentionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4153,7 +4373,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Requires an interactive sandbox session; API keys and legacy permanent tokens are refused. Enabling requires the exact confirmation phrase `delete archived sandbox data`. Disabling affects future archives only and cannot cancel deletion operations already accepted.
      * Update account data-retention policy
      */
-    async updateDataRetention(requestParameters: UpdateDataRetentionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DataRetentionPolicyResponse> {
+    async updateDataRetention(requestParameters: UpdateDataRetentionRequest | runtime.FlatBody<UpdateDataRetentionRequest, 'dataRetentionUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DataRetentionPolicyResponse> {
         const response = await this.updateDataRetentionRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4161,7 +4381,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for updateEnvironment without sending the request
      */
-    async updateEnvironmentRequestOpts(requestParameters: UpdateEnvironmentRequest): Promise<runtime.RequestOpts> {
+    async updateEnvironmentRequestOpts(input: UpdateEnvironmentRequest | runtime.FlatBody<UpdateEnvironmentRequest, 'updateSandboxEnvironmentRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateEnvironmentRequest>(input, 'updateSandboxEnvironmentRequest', ['environmentId'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -4207,7 +4428,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Rename, set as default, and/or edit flags and contents. Any flag or content change mints a new immutable version; existing sandboxes stay on their pinned version until you call upgrade.
      * Update a sandbox environment
      */
-    async updateEnvironmentRaw(requestParameters: UpdateEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentResponse>> {
+    async updateEnvironmentRaw(requestParameters: UpdateEnvironmentRequest | runtime.FlatBody<UpdateEnvironmentRequest, 'updateSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentResponse>> {
         const requestOptions = await this.updateEnvironmentRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4218,7 +4439,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Rename, set as default, and/or edit flags and contents. Any flag or content change mints a new immutable version; existing sandboxes stay on their pinned version until you call upgrade.
      * Update a sandbox environment
      */
-    async updateEnvironment(requestParameters: UpdateEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentResponse> {
+    async updateEnvironment(requestParameters: UpdateEnvironmentRequest | runtime.FlatBody<UpdateEnvironmentRequest, 'updateSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentResponse> {
         const response = await this.updateEnvironmentRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4226,7 +4447,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for updateSecrets without sending the request
      */
-    async updateSecretsRequestOpts(requestParameters: UpdateSecretsRequest): Promise<runtime.RequestOpts> {
+    async updateSecretsRequestOpts(input: UpdateSecretsRequest | runtime.FlatBody<UpdateSecretsRequest, 'secretsUpdateRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateSecretsRequest>(input, 'secretsUpdateRequest', [], []);
         if (requestParameters['secretsUpdateRequest'] == null) {
             throw new runtime.RequiredError(
                 'secretsUpdateRequest',
@@ -4263,7 +4485,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Update Boat secrets setup
      */
-    async updateSecretsRaw(requestParameters: UpdateSecretsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SecretsResponse>> {
+    async updateSecretsRaw(requestParameters: UpdateSecretsRequest | runtime.FlatBody<UpdateSecretsRequest, 'secretsUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SecretsResponse>> {
         const requestOptions = await this.updateSecretsRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4273,7 +4495,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Update Boat secrets setup
      */
-    async updateSecrets(requestParameters: UpdateSecretsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecretsResponse> {
+    async updateSecrets(requestParameters: UpdateSecretsRequest | runtime.FlatBody<UpdateSecretsRequest, 'secretsUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SecretsResponse> {
         const response = await this.updateSecretsRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4281,7 +4503,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for updateWebhook without sending the request
      */
-    async updateWebhookRequestOpts(requestParameters: UpdateWebhookRequest): Promise<runtime.RequestOpts> {
+    async updateWebhookRequestOpts(input: UpdateWebhookRequest | runtime.FlatBody<UpdateWebhookRequest, 'webhookUpdateRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateWebhookRequest>(input, 'webhookUpdateRequest', ['webhookId'], []);
         if (requestParameters['webhookId'] == null) {
             throw new runtime.RequiredError(
                 'webhookId',
@@ -4327,7 +4550,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Updates the name, endpoint URL, or subscribed events without changing the signing secret.
      * Update webhook
      */
-    async updateWebhookRaw(requestParameters: UpdateWebhookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WebhookResponse>> {
+    async updateWebhookRaw(requestParameters: UpdateWebhookRequest | runtime.FlatBody<UpdateWebhookRequest, 'webhookUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WebhookResponse>> {
         const requestOptions = await this.updateWebhookRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4338,7 +4561,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Updates the name, endpoint URL, or subscribed events without changing the signing secret.
      * Update webhook
      */
-    async updateWebhook(requestParameters: UpdateWebhookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WebhookResponse> {
+    async updateWebhook(requestParameters: UpdateWebhookRequest | runtime.FlatBody<UpdateWebhookRequest, 'webhookUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WebhookResponse> {
         const response = await this.updateWebhookRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4346,7 +4569,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for upgradeEnvironment without sending the request
      */
-    async upgradeEnvironmentRequestOpts(requestParameters: UpgradeEnvironmentRequest): Promise<runtime.RequestOpts> {
+    async upgradeEnvironmentRequestOpts(input: UpgradeEnvironmentRequest | runtime.FlatBody<UpgradeEnvironmentRequest, 'upgradeSandboxEnvironmentRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpgradeEnvironmentRequest>(input, 'upgradeSandboxEnvironmentRequest', ['environmentId'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -4385,7 +4609,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Repoints the caller\'s active sandboxes from an older version of this environment to its latest version, scrubbing any owner secrets the new version drops and hot-pushing the new config.
      * Upgrade sandboxes to an environment\'s latest version
      */
-    async upgradeEnvironmentRaw(requestParameters: UpgradeEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UpgradeSandboxEnvironmentResponse>> {
+    async upgradeEnvironmentRaw(requestParameters: UpgradeEnvironmentRequest | runtime.FlatBody<UpgradeEnvironmentRequest, 'upgradeSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UpgradeSandboxEnvironmentResponse>> {
         const requestOptions = await this.upgradeEnvironmentRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4396,7 +4620,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Repoints the caller\'s active sandboxes from an older version of this environment to its latest version, scrubbing any owner secrets the new version drops and hot-pushing the new config.
      * Upgrade sandboxes to an environment\'s latest version
      */
-    async upgradeEnvironment(requestParameters: UpgradeEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UpgradeSandboxEnvironmentResponse> {
+    async upgradeEnvironment(requestParameters: UpgradeEnvironmentRequest | runtime.FlatBody<UpgradeEnvironmentRequest, 'upgradeSandboxEnvironmentRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UpgradeSandboxEnvironmentResponse> {
         const response = await this.upgradeEnvironmentRaw(requestParameters, initOverrides);
         return await response.value();
     }
@@ -4467,7 +4691,8 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for writeFile without sending the request
      */
-    async writeFileRequestOpts(requestParameters: WriteFileRequest): Promise<runtime.RequestOpts> {
+    async writeFileRequestOpts(input: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<WriteFileRequest>(input, 'fileWriteRequest', ['sandboxId'], []);
         if (requestParameters['sandboxId'] == null) {
             throw new runtime.RequiredError(
                 'sandboxId',
@@ -4512,7 +4737,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Write a file in a sandbox
      */
-    async writeFileRaw(requestParameters: WriteFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileWriteResponse>> {
+    async writeFileRaw(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileWriteResponse>> {
         const requestOptions = await this.writeFileRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -4522,7 +4747,7 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Write a file in a sandbox
      */
-    async writeFile(requestParameters: WriteFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileWriteResponse> {
+    async writeFile(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileWriteResponse> {
         const response = await this.writeFileRaw(requestParameters, initOverrides);
         return await response.value();
     }