@boatdev/sdk 1.9.5 → 1.9.7

package/src/apis/BoatApi.ts

@@ -13,6 +13,11 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type AccountAiUsageResponse,
+    AccountAiUsageResponseFromJSON,
+    AccountAiUsageResponseToJSON,
+} from '../models/AccountAiUsageResponse';
 import {
     type ActiveOrgResponse,
     ActiveOrgResponseFromJSON,
@@ -28,6 +33,11 @@ import {
     AddEnvironmentRepoRequestFromJSON,
     AddEnvironmentRepoRequestToJSON,
 } from '../models/AddEnvironmentRepoRequest';
+import {
+    type AiProxySettings,
+    AiProxySettingsFromJSON,
+    AiProxySettingsToJSON,
+} from '../models/AiProxySettings';
 import {
     type ApiKeyRevokeResponse,
     ApiKeyRevokeResponseFromJSON,
@@ -98,6 +108,11 @@ import {
     ConversationsResponseFromJSON,
     ConversationsResponseToJSON,
 } from '../models/ConversationsResponse';
+import {
+    type CreateCredentialProfileRequest,
+    CreateCredentialProfileRequestFromJSON,
+    CreateCredentialProfileRequestToJSON,
+} from '../models/CreateCredentialProfileRequest';
 import {
     type CreateSandboxEnvironmentRequest,
     CreateSandboxEnvironmentRequestFromJSON,
@@ -123,6 +138,31 @@ import {
     CreateScopedApiKeyRequestFromJSON,
     CreateScopedApiKeyRequestToJSON,
 } from '../models/CreateScopedApiKeyRequest';
+import {
+    type CredentialAccountsResponse,
+    CredentialAccountsResponseFromJSON,
+    CredentialAccountsResponseToJSON,
+} from '../models/CredentialAccountsResponse';
+import {
+    type CredentialId,
+    CredentialIdFromJSON,
+    CredentialIdToJSON,
+} from '../models/CredentialId';
+import {
+    type CredentialProfileDeletedResponse,
+    CredentialProfileDeletedResponseFromJSON,
+    CredentialProfileDeletedResponseToJSON,
+} from '../models/CredentialProfileDeletedResponse';
+import {
+    type CredentialProfileListResponse,
+    CredentialProfileListResponseFromJSON,
+    CredentialProfileListResponseToJSON,
+} from '../models/CredentialProfileListResponse';
+import {
+    type CredentialProfileResponse,
+    CredentialProfileResponseFromJSON,
+    CredentialProfileResponseToJSON,
+} from '../models/CredentialProfileResponse';
 import {
     type DataRetentionPolicyResponse,
     DataRetentionPolicyResponseFromJSON,
@@ -318,6 +358,16 @@ import {
     SandboxActionResponseFromJSON,
     SandboxActionResponseToJSON,
 } from '../models/SandboxActionResponse';
+import {
+    type SandboxAiAccessResponse,
+    SandboxAiAccessResponseFromJSON,
+    SandboxAiAccessResponseToJSON,
+} from '../models/SandboxAiAccessResponse';
+import {
+    type SandboxAiUsageResponse,
+    SandboxAiUsageResponseFromJSON,
+    SandboxAiUsageResponseToJSON,
+} from '../models/SandboxAiUsageResponse';
 import {
     type SandboxEnvironmentListResponse,
     SandboxEnvironmentListResponseFromJSON,
@@ -353,6 +403,16 @@ import {
     SecretsUpdateRequestFromJSON,
     SecretsUpdateRequestToJSON,
 } from '../models/SecretsUpdateRequest';
+import {
+    type SetCredentialKeyRequest,
+    SetCredentialKeyRequestFromJSON,
+    SetCredentialKeyRequestToJSON,
+} from '../models/SetCredentialKeyRequest';
+import {
+    type SetCustomApiRequest,
+    SetCustomApiRequestFromJSON,
+    SetCustomApiRequestToJSON,
+} from '../models/SetCustomApiRequest';
 import {
     type SetEnvironmentSecretFileRequest,
     SetEnvironmentSecretFileRequestFromJSON,
@@ -363,6 +423,11 @@ import {
     SetEnvironmentVarRequestFromJSON,
     SetEnvironmentVarRequestToJSON,
 } from '../models/SetEnvironmentVarRequest';
+import {
+    type SetSandboxAiAccessRequest,
+    SetSandboxAiAccessRequestFromJSON,
+    SetSandboxAiAccessRequestToJSON,
+} from '../models/SetSandboxAiAccessRequest';
 import {
     type Share200Response,
     Share200ResponseFromJSON,
@@ -433,6 +498,16 @@ import {
     TelemetrySetResponseFromJSON,
     TelemetrySetResponseToJSON,
 } from '../models/TelemetrySetResponse';
+import {
+    type UpdateAiProxyRequest,
+    UpdateAiProxyRequestFromJSON,
+    UpdateAiProxyRequestToJSON,
+} from '../models/UpdateAiProxyRequest';
+import {
+    type UpdateCredentialProfileRequest,
+    UpdateCredentialProfileRequestFromJSON,
+    UpdateCredentialProfileRequestToJSON,
+} from '../models/UpdateCredentialProfileRequest';
 import {
     type UpdateSandboxEnvironmentRequest,
     UpdateSandboxEnvironmentRequestFromJSON,
@@ -484,9 +559,16 @@ import {
     WebhookUpdateRequestToJSON,
 } from '../models/WebhookUpdateRequest';
 
+export interface AddCredentialAccountRequest {
+    profile: string;
+    credential: CredentialId;
+    setCredentialKeyRequest: SetCredentialKeyRequest;
+}
+
 export interface AddEnvironmentRepoOperationRequest {
     environmentId: string;
     addEnvironmentRepoRequest: AddEnvironmentRepoRequest;
+    org?: string;
 }
 
 export interface ApiKeyUsageRequest {
@@ -546,6 +628,10 @@ export interface CreateRequest {
     createSandboxRequest?: CreateSandboxRequest;
 }
 
+export interface CreateCredentialProfileOperationRequest {
+    createCredentialProfileRequest: CreateCredentialProfileRequest;
+}
+
 export interface CreateDownloadUrlRequest {
     sandboxId: string;
     fileUrlRequest: FileUrlRequest;
@@ -553,6 +639,7 @@ export interface CreateDownloadUrlRequest {
 
 export interface CreateEnvironmentRequest {
     createSandboxEnvironmentRequest: CreateSandboxEnvironmentRequest;
+    org?: string;
 }
 
 export interface CreateScopedApiKeyOperationRequest {
@@ -572,23 +659,47 @@ export interface CreateWebhookRequest {
     webhookCreateRequest: WebhookCreateRequest;
 }
 
+export interface DeleteCredentialAccountRequest {
+    profile: string;
+    credential: CredentialId;
+    account: string;
+}
+
+export interface DeleteCredentialProfileRequest {
+    profile: string;
+}
+
+export interface DeleteCredentialProfileCustomApiRequest {
+    profile: string;
+    name: string;
+}
+
+export interface DeleteCredentialProfileKeyRequest {
+    profile: string;
+    credential: CredentialId;
+}
+
 export interface DeleteEnvironmentRequest {
     environmentId: string;
+    org?: string;
 }
 
 export interface DeleteEnvironmentRepoRequest {
     environmentId: string;
     repositoryId: string;
+    org?: string;
 }
 
 export interface DeleteEnvironmentSecretFileRequest {
     path: string;
     environmentId: string;
+    org?: string;
 }
 
 export interface DeleteEnvironmentVarRequest {
     environmentId: string;
     key: string;
+    org?: string;
 }
 
 export interface DeleteNamedSnapshotRequest {
@@ -621,6 +732,10 @@ export interface DesktopOperationRequest {
     desktopRequest?: DesktopRequest;
 }
 
+export interface EnvironmentsRequest {
+    org?: string;
+}
+
 export interface EventsRequest {
     sandboxId: string;
     limit?: number;
@@ -640,6 +755,18 @@ export interface GetRequest {
     sandboxId: string;
 }
 
+export interface GetAiProxyRequest {
+    org?: string;
+    xBoatOrg?: string;
+}
+
+export interface GetAiUsageRequest {
+    days?: number;
+    profile?: string;
+    org?: string;
+    xBoatOrg?: string;
+}
+
 export interface GetCommandRequest {
     sandboxId: string;
     commandId: string;
@@ -657,6 +784,11 @@ export interface GetNamedSnapshotRequest {
     name: string;
 }
 
+export interface GetSandboxAiUsageRequest {
+    sandboxId: string;
+    days?: number;
+}
+
 export interface GetSnapshotDownloadRequest {
     snapshotId: string;
 }
@@ -695,6 +827,11 @@ export interface LimitsRequest {
     teamId?: string;
 }
 
+export interface ListCredentialAccountsRequest {
+    profile: string;
+    credential: CredentialId;
+}
+
 export interface ListSandboxSnapshotsRequest {
     sandboxId: string;
     limit?: number;
@@ -788,15 +925,34 @@ export interface SetActiveOrganizationRequest {
     activeOrgUpdateRequest: ActiveOrgUpdateRequest;
 }
 
+export interface SetCredentialProfileCustomApiRequest {
+    profile: string;
+    name: string;
+    setCustomApiRequest: SetCustomApiRequest;
+}
+
+export interface SetCredentialProfileKeyRequest {
+    profile: string;
+    credential: CredentialId;
+    setCredentialKeyRequest: SetCredentialKeyRequest;
+}
+
 export interface SetEnvironmentSecretFileOperationRequest {
     environmentId: string;
     setEnvironmentSecretFileRequest: SetEnvironmentSecretFileRequest;
+    org?: string;
 }
 
 export interface SetEnvironmentVarOperationRequest {
     environmentId: string;
     key: string;
     setEnvironmentVarRequest: SetEnvironmentVarRequest;
+    org?: string;
+}
+
+export interface SetSandboxAiAccessOperationRequest {
+    sandboxId: string;
+    setSandboxAiAccessRequest: SetSandboxAiAccessRequest;
 }
 
 export interface SetTelemetryRequest {
@@ -828,11 +984,28 @@ export interface StopCommandRequest {
     processId: number;
 }
 
+export interface SwitchCredentialAccountRequest {
+    profile: string;
+    credential: CredentialId;
+    account: string;
+}
+
 export interface UpdateRequest {
     sandboxId: string;
     updateSandboxRequest: UpdateSandboxRequest;
 }
 
+export interface UpdateAiProxyOperationRequest {
+    updateAiProxyRequest: UpdateAiProxyRequest;
+    org?: string;
+    xBoatOrg?: string;
+}
+
+export interface UpdateCredentialProfileOperationRequest {
+    profile: string;
+    updateCredentialProfileRequest: UpdateCredentialProfileRequest;
+}
+
 export interface UpdateDataRetentionRequest {
     dataRetentionUpdateRequest: DataRetentionUpdateRequest;
 }
@@ -840,6 +1013,7 @@ export interface UpdateDataRetentionRequest {
 export interface UpdateEnvironmentRequest {
     environmentId: string;
     updateSandboxEnvironmentRequest: UpdateSandboxEnvironmentRequest;
+    org?: string;
 }
 
 export interface UpdateSecretsRequest {
@@ -853,6 +1027,7 @@ export interface UpdateWebhookRequest {
 
 export interface UpgradeEnvironmentRequest {
     environmentId: string;
+    org?: string;
     upgradeSandboxEnvironmentRequest?: UpgradeSandboxEnvironmentRequest;
 }
 
@@ -872,11 +1047,85 @@ export interface WriteFileRequest {
  */
 export class BoatApi extends runtime.BaseAPI {
 
+    /**
+     * Creates request options for addCredentialAccount without sending the request
+     */
+    async addCredentialAccountRequestOpts(input: AddCredentialAccountRequest | runtime.FlatBody<AddCredentialAccountRequest, 'setCredentialKeyRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<AddCredentialAccountRequest>(input, 'setCredentialKeyRequest', ['profile', 'credential'], []);
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError(
+                'profile',
+                'Required parameter "profile" was null or undefined when calling addCredentialAccount().'
+            );
+        }
+
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError(
+                'credential',
+                'Required parameter "credential" was null or undefined when calling addCredentialAccount().'
+            );
+        }
+
+        if (requestParameters['setCredentialKeyRequest'] == null) {
+            throw new runtime.RequiredError(
+                'setCredentialKeyRequest',
+                'Required parameter "setCredentialKeyRequest" was null or undefined when calling addCredentialAccount().'
+            );
+        }
+
+        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 = `/credential-profiles/{profile}/accounts/{credential}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SetCredentialKeyRequestToJSON(requestParameters['setCredentialKeyRequest']),
+        };
+    }
+
+    /**
+     * Adds an API key as another account of the credential, ready to switch to. The first key of a credential becomes the one in use. A sign-in returns `400 not_an_api_key`; add another sign-in with \"Add another account\" on the dashboard. Needs an API key with `account.admin`.
+     * Add another API key to a credential
+     */
+    async addCredentialAccountRaw(requestParameters: AddCredentialAccountRequest | runtime.FlatBody<AddCredentialAccountRequest, 'setCredentialKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>> {
+        const requestOptions = await this.addCredentialAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialAccountsResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Adds an API key as another account of the credential, ready to switch to. The first key of a credential becomes the one in use. A sign-in returns `400 not_an_api_key`; add another sign-in with \"Add another account\" on the dashboard. Needs an API key with `account.admin`.
+     * Add another API key to a credential
+     */
+    async addCredentialAccount(requestParameters: AddCredentialAccountRequest | runtime.FlatBody<AddCredentialAccountRequest, 'setCredentialKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse> {
+        const response = await this.addCredentialAccountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for addEnvironmentRepo without sending the request
      */
     async addEnvironmentRepoRequestOpts(input: AddEnvironmentRepoOperationRequest | runtime.FlatBody<AddEnvironmentRepoOperationRequest, 'addEnvironmentRepoRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<AddEnvironmentRepoOperationRequest>(input, 'addEnvironmentRepoRequest', ['environmentId'], []);
+        const requestParameters = runtime.unflattenBody<AddEnvironmentRepoOperationRequest>(input, 'addEnvironmentRepoRequest', ['environmentId', 'org'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -893,6 +1142,10 @@ export class BoatApi extends runtime.BaseAPI {
 
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';
@@ -1586,6 +1839,64 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for createCredentialProfile without sending the request
+     */
+    async createCredentialProfileRequestOpts(input: CreateCredentialProfileOperationRequest | runtime.FlatBody<CreateCredentialProfileOperationRequest, 'createCredentialProfileRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<CreateCredentialProfileOperationRequest>(input, 'createCredentialProfileRequest', [], []);
+        if (requestParameters['createCredentialProfileRequest'] == null) {
+            throw new runtime.RequiredError(
+                'createCredentialProfileRequest',
+                'Required parameter "createCredentialProfileRequest" was null or undefined when calling createCredentialProfile().'
+            );
+        }
+
+        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 = `/credential-profiles`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateCredentialProfileRequestToJSON(requestParameters['createCredentialProfileRequest']),
+        };
+    }
+
+    /**
+     * Creates an empty profile, or a copy of `copyFrom`. With `org`, the profile belongs to that organization and only its owners can create it. Needs an API key with `account.admin`.
+     * Create a credential profile
+     */
+    async createCredentialProfileRaw(requestParameters: CreateCredentialProfileOperationRequest | runtime.FlatBody<CreateCredentialProfileOperationRequest, 'createCredentialProfileRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileResponse>> {
+        const requestOptions = await this.createCredentialProfileRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Creates an empty profile, or a copy of `copyFrom`. With `org`, the profile belongs to that organization and only its owners can create it. Needs an API key with `account.admin`.
+     * Create a credential profile
+     */
+    async createCredentialProfile(requestParameters: CreateCredentialProfileOperationRequest | runtime.FlatBody<CreateCredentialProfileOperationRequest, 'createCredentialProfileRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileResponse> {
+        const response = await this.createCredentialProfileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for createDownloadUrl without sending the request
      */
@@ -1656,7 +1967,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates request options for createEnvironment without sending the request
      */
     async createEnvironmentRequestOpts(input: CreateEnvironmentRequest | runtime.FlatBody<CreateEnvironmentRequest, 'createSandboxEnvironmentRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<CreateEnvironmentRequest>(input, 'createSandboxEnvironmentRequest', [], []);
+        const requestParameters = runtime.unflattenBody<CreateEnvironmentRequest>(input, 'createSandboxEnvironmentRequest', ['org'], []);
         if (requestParameters['createSandboxEnvironmentRequest'] == null) {
             throw new runtime.RequiredError(
                 'createSandboxEnvironmentRequest',
@@ -1666,6 +1977,10 @@ export class BoatApi extends runtime.BaseAPI {
 
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';
@@ -1948,13 +2263,27 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Creates request options for deleteEnvironment without sending the request
+     * Creates request options for deleteCredentialAccount without sending the request
      */
-    async deleteEnvironmentRequestOpts(requestParameters: DeleteEnvironmentRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['environmentId'] == null) {
+    async deleteCredentialAccountRequestOpts(requestParameters: DeleteCredentialAccountRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['profile'] == null) {
             throw new runtime.RequiredError(
-                'environmentId',
-                'Required parameter "environmentId" was null or undefined when calling deleteEnvironment().'
+                'profile',
+                'Required parameter "profile" was null or undefined when calling deleteCredentialAccount().'
+            );
+        }
+
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError(
+                'credential',
+                'Required parameter "credential" was null or undefined when calling deleteCredentialAccount().'
+            );
+        }
+
+        if (requestParameters['account'] == null) {
+            throw new runtime.RequiredError(
+                'account',
+                'Required parameter "account" was null or undefined when calling deleteCredentialAccount().'
             );
         }
 
@@ -1971,8 +2300,10 @@ export class BoatApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/environments/{environmentId}`;
-        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
+        let urlPath = `/credential-profiles/{profile}/accounts/{credential}/{account}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+        urlPath = urlPath.replace('{account}', encodeURIComponent(String(requestParameters['account'])));
 
         return {
             path: urlPath,
@@ -1983,40 +2314,33 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Soft-deletes an environment. The default environment cannot be deleted, and at least one environment is always kept.
-     * Delete a sandbox environment
+     * Deletes an account. For the account in use, the credential switches to another account first, or is removed when it was the last one. Needs an API key with `account.admin`.
+     * Forget an account of a credential
      */
-    async deleteEnvironmentRaw(requestParameters: DeleteEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentResponse>> {
-        const requestOptions = await this.deleteEnvironmentRequestOpts(requestParameters);
+    async deleteCredentialAccountRaw(requestParameters: DeleteCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>> {
+        const requestOptions = await this.deleteCredentialAccountRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SandboxEnvironmentResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialAccountsResponseFromJSON(jsonValue));
     }
 
     /**
-     * Soft-deletes an environment. The default environment cannot be deleted, and at least one environment is always kept.
-     * Delete a sandbox environment
+     * Deletes an account. For the account in use, the credential switches to another account first, or is removed when it was the last one. Needs an API key with `account.admin`.
+     * Forget an account of a credential
      */
-    async deleteEnvironment(requestParameters: DeleteEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentResponse> {
-        const response = await this.deleteEnvironmentRaw(requestParameters, initOverrides);
+    async deleteCredentialAccount(requestParameters: DeleteCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse> {
+        const response = await this.deleteCredentialAccountRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for deleteEnvironmentRepo without sending the request
+     * Creates request options for deleteCredentialProfile without sending the request
      */
-    async deleteEnvironmentRepoRequestOpts(requestParameters: DeleteEnvironmentRepoRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['environmentId'] == null) {
-            throw new runtime.RequiredError(
-                'environmentId',
-                'Required parameter "environmentId" was null or undefined when calling deleteEnvironmentRepo().'
-            );
-        }
-
-        if (requestParameters['repositoryId'] == null) {
+    async deleteCredentialProfileRequestOpts(requestParameters: DeleteCredentialProfileRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['profile'] == null) {
             throw new runtime.RequiredError(
-                'repositoryId',
-                'Required parameter "repositoryId" was null or undefined when calling deleteEnvironmentRepo().'
+                'profile',
+                'Required parameter "profile" was null or undefined when calling deleteCredentialProfile().'
             );
         }
 
@@ -2033,9 +2357,8 @@ export class BoatApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/environments/{environmentId}/repos/{repositoryId}`;
-        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
-        urlPath = urlPath.replace('{repositoryId}', encodeURIComponent(String(requestParameters['repositoryId'])));
+        let urlPath = `/credential-profiles/{profile}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
 
         return {
             path: urlPath,
@@ -2046,49 +2369,45 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Removes one repository from the environment\'s selection. Mints a new immutable version.
-     * Remove a repository from an environment
+     * Deletes the profile. A default profile returns `409 is_default`. A profile that an environment names returns `409 in_use`. Needs an API key with `account.admin`.
+     * Delete a credential profile
      */
-    async deleteEnvironmentRepoRaw(requestParameters: DeleteEnvironmentRepoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
-        const requestOptions = await this.deleteEnvironmentRepoRequestOpts(requestParameters);
+    async deleteCredentialProfileRaw(requestParameters: DeleteCredentialProfileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileDeletedResponse>> {
+        const requestOptions = await this.deleteCredentialProfileRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => EnvironmentItemChangeResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileDeletedResponseFromJSON(jsonValue));
     }
 
     /**
-     * Removes one repository from the environment\'s selection. Mints a new immutable version.
-     * Remove a repository from an environment
+     * Deletes the profile. A default profile returns `409 is_default`. A profile that an environment names returns `409 in_use`. Needs an API key with `account.admin`.
+     * Delete a credential profile
      */
-    async deleteEnvironmentRepo(requestParameters: DeleteEnvironmentRepoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
-        const response = await this.deleteEnvironmentRepoRaw(requestParameters, initOverrides);
+    async deleteCredentialProfile(requestParameters: DeleteCredentialProfileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileDeletedResponse> {
+        const response = await this.deleteCredentialProfileRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for deleteEnvironmentSecretFile without sending the request
+     * Creates request options for deleteCredentialProfileCustomApi without sending the request
      */
-    async deleteEnvironmentSecretFileRequestOpts(requestParameters: DeleteEnvironmentSecretFileRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['path'] == null) {
+    async deleteCredentialProfileCustomApiRequestOpts(requestParameters: DeleteCredentialProfileCustomApiRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['profile'] == null) {
             throw new runtime.RequiredError(
-                'path',
-                'Required parameter "path" was null or undefined when calling deleteEnvironmentSecretFile().'
+                'profile',
+                'Required parameter "profile" was null or undefined when calling deleteCredentialProfileCustomApi().'
             );
         }
 
-        if (requestParameters['environmentId'] == null) {
+        if (requestParameters['name'] == null) {
             throw new runtime.RequiredError(
-                'environmentId',
-                'Required parameter "environmentId" was null or undefined when calling deleteEnvironmentSecretFile().'
+                'name',
+                'Required parameter "name" was null or undefined when calling deleteCredentialProfileCustomApi().'
             );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters['path'] != null) {
-            queryParameters['path'] = requestParameters['path'];
-        }
-
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -2100,8 +2419,9 @@ export class BoatApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/environments/{environmentId}/secret-files`;
-        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
+        let urlPath = `/credential-profiles/{profile}/custom-apis/{name}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{name}', encodeURIComponent(String(requestParameters['name'])));
 
         return {
             path: urlPath,
@@ -2112,40 +2432,40 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Removes the secret file at `path`. Mints a new immutable version.
-     * Remove one secret file
+     * Removes one custom API from the profile. Needs an API key with `account.admin`.
+     * Remove a custom API
      */
-    async deleteEnvironmentSecretFileRaw(requestParameters: DeleteEnvironmentSecretFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
-        const requestOptions = await this.deleteEnvironmentSecretFileRequestOpts(requestParameters);
+    async deleteCredentialProfileCustomApiRaw(requestParameters: DeleteCredentialProfileCustomApiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileResponse>> {
+        const requestOptions = await this.deleteCredentialProfileCustomApiRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => EnvironmentItemChangeResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileResponseFromJSON(jsonValue));
     }
 
     /**
-     * Removes the secret file at `path`. Mints a new immutable version.
-     * Remove one secret file
+     * Removes one custom API from the profile. Needs an API key with `account.admin`.
+     * Remove a custom API
      */
-    async deleteEnvironmentSecretFile(requestParameters: DeleteEnvironmentSecretFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
-        const response = await this.deleteEnvironmentSecretFileRaw(requestParameters, initOverrides);
+    async deleteCredentialProfileCustomApi(requestParameters: DeleteCredentialProfileCustomApiRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileResponse> {
+        const response = await this.deleteCredentialProfileCustomApiRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for deleteEnvironmentVar without sending the request
+     * Creates request options for deleteCredentialProfileKey without sending the request
      */
-    async deleteEnvironmentVarRequestOpts(requestParameters: DeleteEnvironmentVarRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['environmentId'] == null) {
+    async deleteCredentialProfileKeyRequestOpts(requestParameters: DeleteCredentialProfileKeyRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['profile'] == null) {
             throw new runtime.RequiredError(
-                'environmentId',
-                'Required parameter "environmentId" was null or undefined when calling deleteEnvironmentVar().'
+                'profile',
+                'Required parameter "profile" was null or undefined when calling deleteCredentialProfileKey().'
             );
         }
 
-        if (requestParameters['key'] == null) {
+        if (requestParameters['credential'] == null) {
             throw new runtime.RequiredError(
-                'key',
-                'Required parameter "key" was null or undefined when calling deleteEnvironmentVar().'
+                'credential',
+                'Required parameter "credential" was null or undefined when calling deleteCredentialProfileKey().'
             );
         }
 
@@ -2162,9 +2482,9 @@ export class BoatApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/environments/{environmentId}/vars/{key}`;
-        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
-        urlPath = urlPath.replace('{key}', encodeURIComponent(String(requestParameters['key'])));
+        let urlPath = `/credential-profiles/{profile}/keys/{credential}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
 
         return {
             path: urlPath,
@@ -2175,10 +2495,273 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Removes a single variable. Mints a new immutable version.
-     * Remove one environment variable
+     * Removes one credential, an API key or a sign-in. Needs an API key with `account.admin`.
+     * Remove a credential profile credential
      */
-    async deleteEnvironmentVarRaw(requestParameters: DeleteEnvironmentVarRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
+    async deleteCredentialProfileKeyRaw(requestParameters: DeleteCredentialProfileKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileResponse>> {
+        const requestOptions = await this.deleteCredentialProfileKeyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Removes one credential, an API key or a sign-in. Needs an API key with `account.admin`.
+     * Remove a credential profile credential
+     */
+    async deleteCredentialProfileKey(requestParameters: DeleteCredentialProfileKeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileResponse> {
+        const response = await this.deleteCredentialProfileKeyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for deleteEnvironment without sending the request
+     */
+    async deleteEnvironmentRequestOpts(requestParameters: DeleteEnvironmentRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['environmentId'] == null) {
+            throw new runtime.RequiredError(
+                'environmentId',
+                'Required parameter "environmentId" was null or undefined when calling deleteEnvironment().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        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 = `/environments/{environmentId}`;
+        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Soft-deletes an environment. The default environment cannot be deleted, and at least one environment is always kept.
+     * Delete a sandbox environment
+     */
+    async deleteEnvironmentRaw(requestParameters: DeleteEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentResponse>> {
+        const requestOptions = await this.deleteEnvironmentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SandboxEnvironmentResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Soft-deletes an environment. The default environment cannot be deleted, and at least one environment is always kept.
+     * Delete a sandbox environment
+     */
+    async deleteEnvironment(requestParameters: DeleteEnvironmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentResponse> {
+        const response = await this.deleteEnvironmentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for deleteEnvironmentRepo without sending the request
+     */
+    async deleteEnvironmentRepoRequestOpts(requestParameters: DeleteEnvironmentRepoRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['environmentId'] == null) {
+            throw new runtime.RequiredError(
+                'environmentId',
+                'Required parameter "environmentId" was null or undefined when calling deleteEnvironmentRepo().'
+            );
+        }
+
+        if (requestParameters['repositoryId'] == null) {
+            throw new runtime.RequiredError(
+                'repositoryId',
+                'Required parameter "repositoryId" was null or undefined when calling deleteEnvironmentRepo().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        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 = `/environments/{environmentId}/repos/{repositoryId}`;
+        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
+        urlPath = urlPath.replace('{repositoryId}', encodeURIComponent(String(requestParameters['repositoryId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Removes one repository from the environment\'s selection. Mints a new immutable version.
+     * Remove a repository from an environment
+     */
+    async deleteEnvironmentRepoRaw(requestParameters: DeleteEnvironmentRepoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
+        const requestOptions = await this.deleteEnvironmentRepoRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EnvironmentItemChangeResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Removes one repository from the environment\'s selection. Mints a new immutable version.
+     * Remove a repository from an environment
+     */
+    async deleteEnvironmentRepo(requestParameters: DeleteEnvironmentRepoRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
+        const response = await this.deleteEnvironmentRepoRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for deleteEnvironmentSecretFile without sending the request
+     */
+    async deleteEnvironmentSecretFileRequestOpts(requestParameters: DeleteEnvironmentSecretFileRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['path'] == null) {
+            throw new runtime.RequiredError(
+                'path',
+                'Required parameter "path" was null or undefined when calling deleteEnvironmentSecretFile().'
+            );
+        }
+
+        if (requestParameters['environmentId'] == null) {
+            throw new runtime.RequiredError(
+                'environmentId',
+                'Required parameter "environmentId" was null or undefined when calling deleteEnvironmentSecretFile().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['path'] != null) {
+            queryParameters['path'] = requestParameters['path'];
+        }
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        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 = `/environments/{environmentId}/secret-files`;
+        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Removes the secret file at `path`. Mints a new immutable version.
+     * Remove one secret file
+     */
+    async deleteEnvironmentSecretFileRaw(requestParameters: DeleteEnvironmentSecretFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
+        const requestOptions = await this.deleteEnvironmentSecretFileRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EnvironmentItemChangeResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Removes the secret file at `path`. Mints a new immutable version.
+     * Remove one secret file
+     */
+    async deleteEnvironmentSecretFile(requestParameters: DeleteEnvironmentSecretFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse> {
+        const response = await this.deleteEnvironmentSecretFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for deleteEnvironmentVar without sending the request
+     */
+    async deleteEnvironmentVarRequestOpts(requestParameters: DeleteEnvironmentVarRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['environmentId'] == null) {
+            throw new runtime.RequiredError(
+                'environmentId',
+                'Required parameter "environmentId" was null or undefined when calling deleteEnvironmentVar().'
+            );
+        }
+
+        if (requestParameters['key'] == null) {
+            throw new runtime.RequiredError(
+                'key',
+                'Required parameter "key" was null or undefined when calling deleteEnvironmentVar().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        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 = `/environments/{environmentId}/vars/{key}`;
+        urlPath = urlPath.replace('{environmentId}', encodeURIComponent(String(requestParameters['environmentId'])));
+        urlPath = urlPath.replace('{key}', encodeURIComponent(String(requestParameters['key'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Removes a single variable. Mints a new immutable version.
+     * Remove one environment variable
+     */
+    async deleteEnvironmentVarRaw(requestParameters: DeleteEnvironmentVarRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnvironmentItemChangeResponse>> {
         const requestOptions = await this.deleteEnvironmentVarRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
@@ -2619,9 +3202,13 @@ export class BoatApi extends runtime.BaseAPI {
     /**
      * Creates request options for environments without sending the request
      */
-    async environmentsRequestOpts(): Promise<runtime.RequestOpts> {
+    async environmentsRequestOpts(requestParameters: EnvironmentsRequest): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -2647,8 +3234,8 @@ export class BoatApi extends runtime.BaseAPI {
      * Returns every non-deleted sandbox environment with its latest-version flags, contents, and per-version sandbox usage. A default environment named `base` is created on first access if none exists.
      * List Sandbox environments
      */
-    async environmentsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentListResponse>> {
-        const requestOptions = await this.environmentsRequestOpts();
+    async environmentsRaw(requestParameters: EnvironmentsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxEnvironmentListResponse>> {
+        const requestOptions = await this.environmentsRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => SandboxEnvironmentListResponseFromJSON(jsonValue));
@@ -2658,8 +3245,8 @@ export class BoatApi extends runtime.BaseAPI {
      * Returns every non-deleted sandbox environment with its latest-version flags, contents, and per-version sandbox usage. A default environment named `base` is created on first access if none exists.
      * List Sandbox environments
      */
-    async environments(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentListResponse> {
-        const response = await this.environmentsRaw(initOverrides);
+    async environments(requestParameters: EnvironmentsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxEnvironmentListResponse> {
+        const response = await this.environmentsRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -2840,19 +3427,137 @@ export class BoatApi extends runtime.BaseAPI {
      * Poll this endpoint after create, stop, resume, or fork operations.
      * Get sandbox
      */
-    async getRaw(requestParameters: GetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxInfoResponse>> {
-        const requestOptions = await this.getRequestOpts(requestParameters);
+    async getRaw(requestParameters: GetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxInfoResponse>> {
+        const requestOptions = await this.getRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SandboxInfoResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Poll this endpoint after create, stop, resume, or fork operations.
+     * Get sandbox
+     */
+    async get(requestParameters: GetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxInfoResponse> {
+        const response = await this.getRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getAiProxy without sending the request
+     */
+    async getAiProxyRequestOpts(requestParameters: GetAiProxyRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xBoatOrg'] != null) {
+            headerParameters['X-Boat-Org'] = String(requestParameters['xBoatOrg']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/ai-proxy`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Returns the AI credentials proxy switch of the account in scope, a person or an organization, with its price. Needs an API key with `account.admin`.
+     * Get AI credentials proxy
+     */
+    async getAiProxyRaw(requestParameters: GetAiProxyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AiProxySettings>> {
+        const requestOptions = await this.getAiProxyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => AiProxySettingsFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns the AI credentials proxy switch of the account in scope, a person or an organization, with its price. Needs an API key with `account.admin`.
+     * Get AI credentials proxy
+     */
+    async getAiProxy(requestParameters: GetAiProxyRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AiProxySettings> {
+        const response = await this.getAiProxyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getAiUsage without sending the request
+     */
+    async getAiUsageRequestOpts(requestParameters: GetAiUsageRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['days'] != null) {
+            queryParameters['days'] = requestParameters['days'];
+        }
+
+        if (requestParameters['profile'] != null) {
+            queryParameters['profile'] = requestParameters['profile'];
+        }
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xBoatOrg'] != null) {
+            headerParameters['X-Boat-Org'] = String(requestParameters['xBoatOrg']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/ai-usage`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Proxied AI usage, per sandbox and in total, per UTC day, credential and model. Without `profile`, the usage charged to the wallet in scope. With `profile`, the requests made with that profile\'s credentials, whoever pays; only its managers can read it. Needs an API key with `account.read`.
+     * Get AI usage
+     */
+    async getAiUsageRaw(requestParameters: GetAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountAiUsageResponse>> {
+        const requestOptions = await this.getAiUsageRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SandboxInfoResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => AccountAiUsageResponseFromJSON(jsonValue));
     }
 
     /**
-     * Poll this endpoint after create, stop, resume, or fork operations.
-     * Get sandbox
+     * Proxied AI usage, per sandbox and in total, per UTC day, credential and model. Without `profile`, the usage charged to the wallet in scope. With `profile`, the requests made with that profile\'s credentials, whoever pays; only its managers can read it. Needs an API key with `account.read`.
+     * Get AI usage
      */
-    async get(requestParameters: GetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxInfoResponse> {
-        const response = await this.getRaw(requestParameters, initOverrides);
+    async getAiUsage(requestParameters: GetAiUsageRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountAiUsageResponse> {
+        const response = await this.getAiUsageRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -3127,6 +3832,65 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getSandboxAiUsage without sending the request
+     */
+    async getSandboxAiUsageRequestOpts(requestParameters: GetSandboxAiUsageRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling getSandboxAiUsage().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['days'] != null) {
+            queryParameters['days'] = requestParameters['days'];
+        }
+
+        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 = `/sandboxes/{sandboxId}/ai-usage`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * 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.
+     * Get sandbox AI usage
+     */
+    async getSandboxAiUsageRaw(requestParameters: GetSandboxAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxAiUsageResponse>> {
+        const requestOptions = await this.getSandboxAiUsageRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SandboxAiUsageResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * One sandbox\'s proxied AI usage per UTC day, credential and model, and whether it is blocked. Needs an API key with `box.read` on the sandbox.
+     * Get sandbox AI usage
+     */
+    async getSandboxAiUsage(requestParameters: GetSandboxAiUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxAiUsageResponse> {
+        const response = await this.getSandboxAiUsageRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getSnapshotDownload without sending the request
      */
@@ -3645,6 +4409,116 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for listCredentialAccounts without sending the request
+     */
+    async listCredentialAccountsRequestOpts(requestParameters: ListCredentialAccountsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError(
+                'profile',
+                'Required parameter "profile" was null or undefined when calling listCredentialAccounts().'
+            );
+        }
+
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError(
+                'credential',
+                'Required parameter "credential" was null or undefined when calling listCredentialAccounts().'
+            );
+        }
+
+        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 = `/credential-profiles/{profile}/accounts/{credential}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * List the accounts of a credential
+     */
+    async listCredentialAccountsRaw(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>> {
+        const requestOptions = await this.listCredentialAccountsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialAccountsResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Every account of one credential (several ChatGPT sign-ins, several OpenAI keys), in the order they were added, the one in use marked. Labels only, never a secret. Needs an API key with `account.admin`.
+     * List the accounts of a credential
+     */
+    async listCredentialAccounts(requestParameters: ListCredentialAccountsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse> {
+        const response = await this.listCredentialAccountsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for listCredentialProfiles without sending the request
+     */
+    async listCredentialProfilesRequestOpts(): 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 = `/credential-profiles`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Returns every AI credential profile you can use, yours and your organizations\'. Secret values are never returned. Needs an API key with `account.admin`.
+     * List credential profiles
+     */
+    async listCredentialProfilesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileListResponse>> {
+        const requestOptions = await this.listCredentialProfilesRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileListResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns every AI credential profile you can use, yours and your organizations\'. Secret values are never returned. Needs an API key with `account.admin`.
+     * List credential profiles
+     */
+    async listCredentialProfiles(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileListResponse> {
+        const response = await this.listCredentialProfilesRaw(initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for listNamedSnapshots without sending the request
      */
@@ -4855,15 +5729,145 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
-    /**
-     * Creates request options for selectRepo without sending the request
-     */
-    async selectRepoRequestOpts(input: SelectRepoRequest | runtime.FlatBody<SelectRepoRequest, 'repoSelectionRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<SelectRepoRequest>(input, 'repoSelectionRequest', [], []);
-        if (requestParameters['repoSelectionRequest'] == null) {
+    /**
+     * Creates request options for selectRepo without sending the request
+     */
+    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',
+                'Required parameter "repoSelectionRequest" was null or undefined when calling selectRepo().'
+            );
+        }
+
+        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 = `/repos`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: RepoSelectionRequestToJSON(requestParameters['repoSelectionRequest']),
+        };
+    }
+
+    /**
+     * 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 | 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);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => RepoSelectionResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * 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 | 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 setCredentialProfileCustomApi without sending the request
+     */
+    async setCredentialProfileCustomApiRequestOpts(input: SetCredentialProfileCustomApiRequest | runtime.FlatBody<SetCredentialProfileCustomApiRequest, 'setCustomApiRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetCredentialProfileCustomApiRequest>(input, 'setCustomApiRequest', ['profile', 'name'], []);
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError(
+                'profile',
+                'Required parameter "profile" was null or undefined when calling setCredentialProfileCustomApi().'
+            );
+        }
+
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError(
+                'name',
+                'Required parameter "name" was null or undefined when calling setCredentialProfileCustomApi().'
+            );
+        }
+
+        if (requestParameters['setCustomApiRequest'] == null) {
             throw new runtime.RequiredError(
-                'repoSelectionRequest',
-                'Required parameter "repoSelectionRequest" was null or undefined when calling selectRepo().'
+                'setCustomApiRequest',
+                'Required parameter "setCustomApiRequest" was null or undefined when calling setCredentialProfileCustomApi().'
             );
         }
 
@@ -4882,46 +5886,62 @@ export class BoatApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/repos`;
+        let urlPath = `/credential-profiles/{profile}/custom-apis/{name}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{name}', encodeURIComponent(String(requestParameters['name'])));
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: RepoSelectionRequestToJSON(requestParameters['repoSelectionRequest']),
+            body: SetCustomApiRequestToJSON(requestParameters['setCustomApiRequest']),
         };
     }
 
     /**
-     * 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
+     * Adds or replaces one custom API. The sandbox gets `<NAME>` and `<NAME>_BASE_URL`. Needs an API key with `account.admin`.
+     * Set a custom API
      */
-    async selectRepoRaw(requestParameters: SelectRepoRequest | runtime.FlatBody<SelectRepoRequest, 'repoSelectionRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RepoSelectionResponse>> {
-        const requestOptions = await this.selectRepoRequestOpts(requestParameters);
+    async setCredentialProfileCustomApiRaw(requestParameters: SetCredentialProfileCustomApiRequest | runtime.FlatBody<SetCredentialProfileCustomApiRequest, 'setCustomApiRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileResponse>> {
+        const requestOptions = await this.setCredentialProfileCustomApiRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => RepoSelectionResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileResponseFromJSON(jsonValue));
     }
 
     /**
-     * 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
+     * Adds or replaces one custom API. The sandbox gets `<NAME>` and `<NAME>_BASE_URL`. Needs an API key with `account.admin`.
+     * Set a custom API
      */
-    async selectRepo(requestParameters: SelectRepoRequest | runtime.FlatBody<SelectRepoRequest, 'repoSelectionRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RepoSelectionResponse> {
-        const response = await this.selectRepoRaw(requestParameters, initOverrides);
+    async setCredentialProfileCustomApi(requestParameters: SetCredentialProfileCustomApiRequest | runtime.FlatBody<SetCredentialProfileCustomApiRequest, 'setCustomApiRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileResponse> {
+        const response = await this.setCredentialProfileCustomApiRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for setActiveOrganization without sending the request
+     * Creates request options for setCredentialProfileKey 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) {
+    async setCredentialProfileKeyRequestOpts(input: SetCredentialProfileKeyRequest | runtime.FlatBody<SetCredentialProfileKeyRequest, 'setCredentialKeyRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetCredentialProfileKeyRequest>(input, 'setCredentialKeyRequest', ['profile', 'credential'], []);
+        if (requestParameters['profile'] == null) {
             throw new runtime.RequiredError(
-                'activeOrgUpdateRequest',
-                'Required parameter "activeOrgUpdateRequest" was null or undefined when calling setActiveOrganization().'
+                'profile',
+                'Required parameter "profile" was null or undefined when calling setCredentialProfileKey().'
+            );
+        }
+
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError(
+                'credential',
+                'Required parameter "credential" was null or undefined when calling setCredentialProfileKey().'
+            );
+        }
+
+        if (requestParameters['setCredentialKeyRequest'] == null) {
+            throw new runtime.RequiredError(
+                'setCredentialKeyRequest',
+                'Required parameter "setCredentialKeyRequest" was null or undefined when calling setCredentialProfileKey().'
             );
         }
 
@@ -4940,34 +5960,36 @@ export class BoatApi extends runtime.BaseAPI {
             }
         }
 
-        let urlPath = `/orgs/active`;
+        let urlPath = `/credential-profiles/{profile}/keys/{credential}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
 
         return {
             path: urlPath,
-            method: 'PATCH',
+            method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: ActiveOrgUpdateRequestToJSON(requestParameters['activeOrgUpdateRequest']),
+            body: SetCredentialKeyRequestToJSON(requestParameters['setCredentialKeyRequest']),
         };
     }
 
     /**
-     * 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
+     * Sets one API key. A sign-in id returns `400 not_an_api_key`; connect sign-ins on the dashboard Agents page. Running sandboxes that use the profile get the new key. Needs an API key with `account.admin`.
+     * Set a credential profile API key
      */
-    async setActiveOrganizationRaw(requestParameters: SetActiveOrganizationRequest | runtime.FlatBody<SetActiveOrganizationRequest, 'activeOrgUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ActiveOrgResponse>> {
-        const requestOptions = await this.setActiveOrganizationRequestOpts(requestParameters);
+    async setCredentialProfileKeyRaw(requestParameters: SetCredentialProfileKeyRequest | runtime.FlatBody<SetCredentialProfileKeyRequest, 'setCredentialKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileResponse>> {
+        const requestOptions = await this.setCredentialProfileKeyRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ActiveOrgResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileResponseFromJSON(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
+     * Sets one API key. A sign-in id returns `400 not_an_api_key`; connect sign-ins on the dashboard Agents page. Running sandboxes that use the profile get the new key. Needs an API key with `account.admin`.
+     * Set a credential profile API key
      */
-    async setActiveOrganization(requestParameters: SetActiveOrganizationRequest | runtime.FlatBody<SetActiveOrganizationRequest, 'activeOrgUpdateRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ActiveOrgResponse> {
-        const response = await this.setActiveOrganizationRaw(requestParameters, initOverrides);
+    async setCredentialProfileKey(requestParameters: SetCredentialProfileKeyRequest | runtime.FlatBody<SetCredentialProfileKeyRequest, 'setCredentialKeyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileResponse> {
+        const response = await this.setCredentialProfileKeyRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -4975,7 +5997,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates request options for setEnvironmentSecretFile without sending the request
      */
     async setEnvironmentSecretFileRequestOpts(input: SetEnvironmentSecretFileOperationRequest | runtime.FlatBody<SetEnvironmentSecretFileOperationRequest, 'setEnvironmentSecretFileRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<SetEnvironmentSecretFileOperationRequest>(input, 'setEnvironmentSecretFileRequest', ['environmentId'], []);
+        const requestParameters = runtime.unflattenBody<SetEnvironmentSecretFileOperationRequest>(input, 'setEnvironmentSecretFileRequest', ['environmentId', 'org'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -4992,6 +6014,10 @@ export class BoatApi extends runtime.BaseAPI {
 
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';
@@ -5041,7 +6067,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates request options for setEnvironmentVar without sending the request
      */
     async setEnvironmentVarRequestOpts(input: SetEnvironmentVarOperationRequest | runtime.FlatBody<SetEnvironmentVarOperationRequest, 'setEnvironmentVarRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<SetEnvironmentVarOperationRequest>(input, 'setEnvironmentVarRequest', ['environmentId', 'key'], []);
+        const requestParameters = runtime.unflattenBody<SetEnvironmentVarOperationRequest>(input, 'setEnvironmentVarRequest', ['environmentId', 'key', 'org'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -5065,6 +6091,10 @@ export class BoatApi extends runtime.BaseAPI {
 
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';
@@ -5111,6 +6141,72 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for setSandboxAiAccess without sending the request
+     */
+    async setSandboxAiAccessRequestOpts(input: SetSandboxAiAccessOperationRequest | runtime.FlatBody<SetSandboxAiAccessOperationRequest, 'setSandboxAiAccessRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetSandboxAiAccessOperationRequest>(input, 'setSandboxAiAccessRequest', ['sandboxId'], []);
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling setSandboxAiAccess().'
+            );
+        }
+
+        if (requestParameters['setSandboxAiAccessRequest'] == null) {
+            throw new runtime.RequiredError(
+                'setSandboxAiAccessRequest',
+                'Required parameter "setSandboxAiAccessRequest" was null or undefined when calling setSandboxAiAccess().'
+            );
+        }
+
+        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 = `/sandboxes/{sandboxId}/ai-access`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SetSandboxAiAccessRequestToJSON(requestParameters['setSandboxAiAccessRequest']),
+        };
+    }
+
+    /**
+     * Blocks or unblocks the sandbox\'s AI placeholders, running or stopped. The proxy refuses a blocked sandbox\'s requests with `403`. It has no effect on a sandbox that holds real keys. The sandbox creator, or a manager of its credential profile, can call it. Needs an API key with `account.admin`.
+     * Block or unblock sandbox AI access
+     */
+    async setSandboxAiAccessRaw(requestParameters: SetSandboxAiAccessOperationRequest | runtime.FlatBody<SetSandboxAiAccessOperationRequest, 'setSandboxAiAccessRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxAiAccessResponse>> {
+        const requestOptions = await this.setSandboxAiAccessRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => SandboxAiAccessResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Blocks or unblocks the sandbox\'s AI placeholders, running or stopped. The proxy refuses a blocked sandbox\'s requests with `403`. It has no effect on a sandbox that holds real keys. The sandbox creator, or a manager of its credential profile, can call it. Needs an API key with `account.admin`.
+     * Block or unblock sandbox AI access
+     */
+    async setSandboxAiAccess(requestParameters: SetSandboxAiAccessOperationRequest | runtime.FlatBody<SetSandboxAiAccessOperationRequest, 'setSandboxAiAccessRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxAiAccessResponse> {
+        const response = await this.setSandboxAiAccessRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for setTelemetry without sending the request
      */
@@ -5482,6 +6578,77 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for switchCredentialAccount without sending the request
+     */
+    async switchCredentialAccountRequestOpts(requestParameters: SwitchCredentialAccountRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError(
+                'profile',
+                'Required parameter "profile" was null or undefined when calling switchCredentialAccount().'
+            );
+        }
+
+        if (requestParameters['credential'] == null) {
+            throw new runtime.RequiredError(
+                'credential',
+                'Required parameter "credential" was null or undefined when calling switchCredentialAccount().'
+            );
+        }
+
+        if (requestParameters['account'] == null) {
+            throw new runtime.RequiredError(
+                'account',
+                'Required parameter "account" was null or undefined when calling switchCredentialAccount().'
+            );
+        }
+
+        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 = `/credential-profiles/{profile}/accounts/{credential}/{account}/active`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+        urlPath = urlPath.replace('{credential}', encodeURIComponent(String(requestParameters['credential'])));
+        urlPath = urlPath.replace('{account}', encodeURIComponent(String(requestParameters['account'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Makes this account the one in use; the previous one stays as another account. Switching to the account already in use changes nothing. Every sandbox that uses the profile gets it at once, running ones included, with no restart. Use it when one account runs out of credits. Needs an API key with `account.admin`.
+     * Switch a credential to another account
+     */
+    async switchCredentialAccountRaw(requestParameters: SwitchCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialAccountsResponse>> {
+        const requestOptions = await this.switchCredentialAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialAccountsResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Makes this account the one in use; the previous one stays as another account. Switching to the account already in use changes nothing. Every sandbox that uses the profile gets it at once, running ones included, with no restart. Use it when one account runs out of credits. Needs an API key with `account.admin`.
+     * Switch a credential to another account
+     */
+    async switchCredentialAccount(requestParameters: SwitchCredentialAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialAccountsResponse> {
+        const response = await this.switchCredentialAccountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for update without sending the request
      */
@@ -5546,6 +6713,138 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for updateAiProxy without sending the request
+     */
+    async updateAiProxyRequestOpts(input: UpdateAiProxyOperationRequest | runtime.FlatBody<UpdateAiProxyOperationRequest, 'updateAiProxyRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateAiProxyOperationRequest>(input, 'updateAiProxyRequest', ['org', 'xBoatOrg'], []);
+        if (requestParameters['updateAiProxyRequest'] == null) {
+            throw new runtime.RequiredError(
+                'updateAiProxyRequest',
+                'Required parameter "updateAiProxyRequest" was null or undefined when calling updateAiProxy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xBoatOrg'] != null) {
+            headerParameters['X-Boat-Org'] = String(requestParameters['xBoatOrg']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+
+        let urlPath = `/ai-proxy`;
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: UpdateAiProxyRequestToJSON(requestParameters['updateAiProxyRequest']),
+        };
+    }
+
+    /**
+     * With the proxy on, sandboxes get placeholder keys and base URLs that point at Boat. Boat swaps in the real key on each request. Real keys never enter the sandbox.  Running sandboxes switch at their next start. While on, the account pays $1 of Boat time for each UTC day, plus $1 per 1,000 proxied requests, charged to the wallet each sandbox bills. For an organization, only its owner can change the switch. Needs an API key with `account.admin`. 
+     * Turn the AI credentials proxy on or off
+     */
+    async updateAiProxyRaw(requestParameters: UpdateAiProxyOperationRequest | runtime.FlatBody<UpdateAiProxyOperationRequest, 'updateAiProxyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AiProxySettings>> {
+        const requestOptions = await this.updateAiProxyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => AiProxySettingsFromJSON(jsonValue));
+    }
+
+    /**
+     * With the proxy on, sandboxes get placeholder keys and base URLs that point at Boat. Boat swaps in the real key on each request. Real keys never enter the sandbox.  Running sandboxes switch at their next start. While on, the account pays $1 of Boat time for each UTC day, plus $1 per 1,000 proxied requests, charged to the wallet each sandbox bills. For an organization, only its owner can change the switch. Needs an API key with `account.admin`. 
+     * Turn the AI credentials proxy on or off
+     */
+    async updateAiProxy(requestParameters: UpdateAiProxyOperationRequest | runtime.FlatBody<UpdateAiProxyOperationRequest, 'updateAiProxyRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AiProxySettings> {
+        const response = await this.updateAiProxyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateCredentialProfile without sending the request
+     */
+    async updateCredentialProfileRequestOpts(input: UpdateCredentialProfileOperationRequest | runtime.FlatBody<UpdateCredentialProfileOperationRequest, 'updateCredentialProfileRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<UpdateCredentialProfileOperationRequest>(input, 'updateCredentialProfileRequest', ['profile'], []);
+        if (requestParameters['profile'] == null) {
+            throw new runtime.RequiredError(
+                'profile',
+                'Required parameter "profile" was null or undefined when calling updateCredentialProfile().'
+            );
+        }
+
+        if (requestParameters['updateCredentialProfileRequest'] == null) {
+            throw new runtime.RequiredError(
+                'updateCredentialProfileRequest',
+                'Required parameter "updateCredentialProfileRequest" was null or undefined when calling updateCredentialProfile().'
+            );
+        }
+
+        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 = `/credential-profiles/{profile}`;
+        urlPath = urlPath.replace('{profile}', encodeURIComponent(String(requestParameters['profile'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: UpdateCredentialProfileRequestToJSON(requestParameters['updateCredentialProfileRequest']),
+        };
+    }
+
+    /**
+     * Renames the profile, or makes it its owner\'s default. Sandboxes that use the owner\'s default switch to the new default at their next start. Needs an API key with `account.admin`.
+     * Update a credential profile
+     */
+    async updateCredentialProfileRaw(requestParameters: UpdateCredentialProfileOperationRequest | runtime.FlatBody<UpdateCredentialProfileOperationRequest, 'updateCredentialProfileRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CredentialProfileResponse>> {
+        const requestOptions = await this.updateCredentialProfileRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CredentialProfileResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Renames the profile, or makes it its owner\'s default. Sandboxes that use the owner\'s default switch to the new default at their next start. Needs an API key with `account.admin`.
+     * Update a credential profile
+     */
+    async updateCredentialProfile(requestParameters: UpdateCredentialProfileOperationRequest | runtime.FlatBody<UpdateCredentialProfileOperationRequest, 'updateCredentialProfileRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CredentialProfileResponse> {
+        const response = await this.updateCredentialProfileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for updateDataRetention without sending the request
      */
@@ -5608,7 +6907,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates request options for updateEnvironment without sending the request
      */
     async updateEnvironmentRequestOpts(input: UpdateEnvironmentRequest | runtime.FlatBody<UpdateEnvironmentRequest, 'updateSandboxEnvironmentRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<UpdateEnvironmentRequest>(input, 'updateSandboxEnvironmentRequest', ['environmentId'], []);
+        const requestParameters = runtime.unflattenBody<UpdateEnvironmentRequest>(input, 'updateSandboxEnvironmentRequest', ['environmentId', 'org'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -5625,6 +6924,10 @@ export class BoatApi extends runtime.BaseAPI {
 
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';
@@ -5796,7 +7099,7 @@ export class BoatApi extends runtime.BaseAPI {
      * Creates request options for upgradeEnvironment without sending the request
      */
     async upgradeEnvironmentRequestOpts(input: UpgradeEnvironmentRequest | runtime.FlatBody<UpgradeEnvironmentRequest, 'upgradeSandboxEnvironmentRequest'>): Promise<runtime.RequestOpts> {
-        const requestParameters = runtime.unflattenBody<UpgradeEnvironmentRequest>(input, 'upgradeSandboxEnvironmentRequest', ['environmentId'], []);
+        const requestParameters = runtime.unflattenBody<UpgradeEnvironmentRequest>(input, 'upgradeSandboxEnvironmentRequest', ['environmentId', 'org'], []);
         if (requestParameters['environmentId'] == null) {
             throw new runtime.RequiredError(
                 'environmentId',
@@ -5806,6 +7109,10 @@ export class BoatApi extends runtime.BaseAPI {
 
         const queryParameters: any = {};
 
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';