@boatdev/sdk 1.9.2 → 1.9.3

package/src/apis/BoatApi.ts

@@ -53,6 +53,26 @@ import {
     Command200ResponseFromJSON,
     Command200ResponseToJSON,
 } from '../models/Command200Response';
+import {
+    type CommandAttachFrame,
+    CommandAttachFrameFromJSON,
+    CommandAttachFrameToJSON,
+} from '../models/CommandAttachFrame';
+import {
+    type CommandInfoResponse,
+    CommandInfoResponseFromJSON,
+    CommandInfoResponseToJSON,
+} from '../models/CommandInfoResponse';
+import {
+    type CommandListResponse,
+    CommandListResponseFromJSON,
+    CommandListResponseToJSON,
+} from '../models/CommandListResponse';
+import {
+    type CommandLogsResponse,
+    CommandLogsResponseFromJSON,
+    CommandLogsResponseToJSON,
+} from '../models/CommandLogsResponse';
 import {
     type CommandRequest,
     CommandRequestFromJSON,
@@ -63,6 +83,11 @@ import {
     CommandStatusResponseFromJSON,
     CommandStatusResponseToJSON,
 } from '../models/CommandStatusResponse';
+import {
+    type CommandStopResponse,
+    CommandStopResponseFromJSON,
+    CommandStopResponseToJSON,
+} from '../models/CommandStopResponse';
 import {
     type CommandStreamFrame,
     CommandStreamFrameFromJSON,
@@ -228,6 +253,11 @@ import {
     OrgListResponseFromJSON,
     OrgListResponseToJSON,
 } from '../models/OrgListResponse';
+import {
+    type ProcessListResponse,
+    ProcessListResponseFromJSON,
+    ProcessListResponseToJSON,
+} from '../models/ProcessListResponse';
 import {
     type PromptRequest,
     PromptRequestFromJSON,
@@ -378,6 +408,21 @@ import {
     StopRequestFromJSON,
     StopRequestToJSON,
 } from '../models/StopRequest';
+import {
+    type TelemetryResponse,
+    TelemetryResponseFromJSON,
+    TelemetryResponseToJSON,
+} from '../models/TelemetryResponse';
+import {
+    type TelemetrySetRequest,
+    TelemetrySetRequestFromJSON,
+    TelemetrySetRequestToJSON,
+} from '../models/TelemetrySetRequest';
+import {
+    type TelemetrySetResponse,
+    TelemetrySetResponseFromJSON,
+    TelemetrySetResponseToJSON,
+} from '../models/TelemetrySetResponse';
 import {
     type UpdateSandboxEnvironmentRequest,
     UpdateSandboxEnvironmentRequestFromJSON,
@@ -443,15 +488,41 @@ export interface ArtifactRequest {
     path: string;
 }
 
+export interface AttachCommandRequest {
+    sandboxId: string;
+    processId: number;
+    stdoutOffset?: number;
+    stderrOffset?: number;
+}
+
 export interface CommandOperationRequest {
     sandboxId: string;
     commandRequest: CommandRequest;
 }
 
+export interface CommandHistoryRequest {
+    sandboxId: string;
+    mode?: string;
+    q?: string;
+    limit?: number;
+    cursor?: string;
+}
+
+export interface CommandLogsRequest {
+    sandboxId: string;
+    commandId: string;
+    stream?: CommandLogsStreamEnum;
+    offset?: number;
+    limit?: number;
+    encoding?: CommandLogsEncodingEnum;
+}
+
 export interface CommandStatusRequest {
     sandboxId: string;
     processId: number;
     tailBytes?: number;
+    stdoutOffset?: number;
+    stderrOffset?: number;
 }
 
 export interface ConversationsRequest {
@@ -549,6 +620,11 @@ export interface GetRequest {
     sandboxId: string;
 }
 
+export interface GetCommandRequest {
+    sandboxId: string;
+    commandId: string;
+}
+
 export interface GetDeletionOperationRequest {
     operationId: string;
 }
@@ -616,6 +692,10 @@ export interface ListSnapshotsRequest {
     sort?: ListSnapshotsSortEnum;
 }
 
+export interface ProcessesRequest {
+    sandboxId: string;
+}
+
 export interface PromptOperationRequest {
     sandboxId: string;
     promptRequest: PromptRequest;
@@ -699,6 +779,10 @@ export interface SetEnvironmentVarOperationRequest {
     setEnvironmentVarRequest: SetEnvironmentVarRequest;
 }
 
+export interface SetTelemetryRequest {
+    telemetrySetRequest: TelemetrySetRequest;
+}
+
 export interface ShareRequest {
     sandboxId: string;
 }
@@ -719,6 +803,11 @@ export interface StopOperationRequest {
     stopRequest?: StopRequest;
 }
 
+export interface StopCommandRequest {
+    sandboxId: string;
+    processId: number;
+}
+
 export interface UpdateRequest {
     sandboxId: string;
     updateSandboxRequest: UpdateSandboxRequest;
@@ -997,6 +1086,77 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for attachCommand without sending the request
+     */
+    async attachCommandRequestOpts(requestParameters: AttachCommandRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling attachCommand().'
+            );
+        }
+
+        if (requestParameters['processId'] == null) {
+            throw new runtime.RequiredError(
+                'processId',
+                'Required parameter "processId" was null or undefined when calling attachCommand().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['stdoutOffset'] != null) {
+            queryParameters['stdoutOffset'] = requestParameters['stdoutOffset'];
+        }
+
+        if (requestParameters['stderrOffset'] != null) {
+            queryParameters['stderrOffset'] = requestParameters['stderrOffset'];
+        }
+
+        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}/commands/{processId}/stream`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{processId}', encodeURIComponent(String(requestParameters['processId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * The output of a detached command as it is written, one JSON object per line, until the command ends. After 10 minutes the stream ends with a `reconnect` line: open it again with its offsets to continue with no gap. One open stream replaces polling. Needs the `exec` key scope.
+     * Attach to a detached command
+     */
+    async attachCommandRaw(requestParameters: AttachCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CommandAttachFrame>> {
+        const requestOptions = await this.attachCommandRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandAttachFrameFromJSON(jsonValue));
+    }
+
+    /**
+     * The output of a detached command as it is written, one JSON object per line, until the command ends. After 10 minutes the stream ends with a `reconnect` line: open it again with its offsets to continue with no gap. One open stream replaces polling. Needs the `exec` key scope.
+     * Attach to a detached command
+     */
+    async attachCommand(requestParameters: AttachCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandAttachFrame> {
+        const response = await this.attachCommandRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for command without sending the request
      */
@@ -1044,7 +1204,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox. Every command and its output are kept 90 days in the command history (`/sandboxes/{sandboxId}/command-history`), readable while the sandbox is stopped.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>> {
@@ -1055,7 +1215,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox. Every command and its output are kept 90 days in the command history (`/sandboxes/{sandboxId}/command-history`), readable while the sandbox is stopped.
      * Execute a command in a sandbox
      */
     async command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response> {
@@ -1063,6 +1223,156 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for commandHistory without sending the request
+     */
+    async commandHistoryRequestOpts(requestParameters: CommandHistoryRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling commandHistory().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['mode'] != null) {
+            queryParameters['mode'] = requestParameters['mode'];
+        }
+
+        if (requestParameters['q'] != null) {
+            queryParameters['q'] = requestParameters['q'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['cursor'] != null) {
+            queryParameters['cursor'] = requestParameters['cursor'];
+        }
+
+        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}/command-history`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Every command run through `POST /sandboxes/{sandboxId}/commands` in the last 90 days, and every other process that wrote to its stdout/stderr in the last 72 hours (mode `process`), newest first. Works while the sandbox is stopped.
+     * List the command and process history
+     */
+    async commandHistoryRaw(requestParameters: CommandHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CommandListResponse>> {
+        const requestOptions = await this.commandHistoryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandListResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Every command run through `POST /sandboxes/{sandboxId}/commands` in the last 90 days, and every other process that wrote to its stdout/stderr in the last 72 hours (mode `process`), newest first. Works while the sandbox is stopped.
+     * List the command and process history
+     */
+    async commandHistory(requestParameters: CommandHistoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandListResponse> {
+        const response = await this.commandHistoryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for commandLogs without sending the request
+     */
+    async commandLogsRequestOpts(requestParameters: CommandLogsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling commandLogs().'
+            );
+        }
+
+        if (requestParameters['commandId'] == null) {
+            throw new runtime.RequiredError(
+                'commandId',
+                'Required parameter "commandId" was null or undefined when calling commandLogs().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['stream'] != null) {
+            queryParameters['stream'] = requestParameters['stream'];
+        }
+
+        if (requestParameters['offset'] != null) {
+            queryParameters['offset'] = requestParameters['offset'];
+        }
+
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+
+        if (requestParameters['encoding'] != null) {
+            queryParameters['encoding'] = requestParameters['encoding'];
+        }
+
+        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}/command-history/{commandId}/logs`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{commandId}', encodeURIComponent(String(requestParameters['commandId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Reads stdout or stderr from a byte offset, at most 1 MiB per call. Read on with `nextOffset` until `done`. A running detached command gains output every 30 s; a streamed one every 2 s. Works while the sandbox is stopped.
+     * Read a command\'s stored output
+     */
+    async commandLogsRaw(requestParameters: CommandLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CommandLogsResponse>> {
+        const requestOptions = await this.commandLogsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandLogsResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Reads stdout or stderr from a byte offset, at most 1 MiB per call. Read on with `nextOffset` until `done`. A running detached command gains output every 30 s; a streamed one every 2 s. Works while the sandbox is stopped.
+     * Read a command\'s stored output
+     */
+    async commandLogs(requestParameters: CommandLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandLogsResponse> {
+        const response = await this.commandLogsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for commandStatus without sending the request
      */
@@ -1087,6 +1397,14 @@ export class BoatApi extends runtime.BaseAPI {
             queryParameters['tailBytes'] = requestParameters['tailBytes'];
         }
 
+        if (requestParameters['stdoutOffset'] != null) {
+            queryParameters['stdoutOffset'] = requestParameters['stdoutOffset'];
+        }
+
+        if (requestParameters['stderrOffset'] != null) {
+            queryParameters['stderrOffset'] = requestParameters['stderrOffset'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.accessToken) {
@@ -1111,6 +1429,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Without offsets, the answer holds the end of each log. With `stdoutOffset` or `stderrOffset`, it holds only the output written since those byte offsets, so each poll returns only new output. A sandbox agent too old for offsets answers 409 `agent_outdated`.
      * Get detached command status and logs
      */
     async commandStatusRaw(requestParameters: CommandStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CommandStatusResponse>> {
@@ -1121,6 +1440,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
+     * Without offsets, the answer holds the end of each log. With `stdoutOffset` or `stderrOffset`, it holds only the output written since those byte offsets, so each poll returns only new output. A sandbox agent too old for offsets answers 409 `agent_outdated`.
      * Get detached command status and logs
      */
     async commandStatus(requestParameters: CommandStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandStatusResponse> {
@@ -1975,6 +2295,53 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for deleteTelemetry without sending the request
+     */
+    async deleteTelemetryRequestOpts(): 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 = `/telemetry`;
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Removes the export and its queued deliveries. Needs an API key with `account.admin`.
+     * Remove OpenTelemetry export
+     */
+    async deleteTelemetryRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TelemetryResponse>> {
+        const requestOptions = await this.deleteTelemetryRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TelemetryResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Removes the export and its queued deliveries. Needs an API key with `account.admin`.
+     * Remove OpenTelemetry export
+     */
+    async deleteTelemetry(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TelemetryResponse> {
+        const response = await this.deleteTelemetryRaw(initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for deleteWebhook without sending the request
      */
@@ -2337,6 +2704,67 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getCommand without sending the request
+     */
+    async getCommandRequestOpts(requestParameters: GetCommandRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling getCommand().'
+            );
+        }
+
+        if (requestParameters['commandId'] == null) {
+            throw new runtime.RequiredError(
+                'commandId',
+                'Required parameter "commandId" was null or undefined when calling getCommand().'
+            );
+        }
+
+        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 = `/sandboxes/{sandboxId}/command-history/{commandId}`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{commandId}', encodeURIComponent(String(requestParameters['commandId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get one command from the history
+     */
+    async getCommandRaw(requestParameters: GetCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CommandInfoResponse>> {
+        const requestOptions = await this.getCommandRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandInfoResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get one command from the history
+     */
+    async getCommand(requestParameters: GetCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandInfoResponse> {
+        const response = await this.getCommandRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getDataRetention without sending the request
      */
@@ -2642,7 +3070,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`).
+     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`). File responses accept a single `Range: bytes=` header and answer 206 with `Content-Range`, so large files can be downloaded in parts and resumed.
      * Download a file or folder from a snapshot
      */
     async getSnapshotFileRaw(requestParameters: GetSnapshotFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
@@ -2653,7 +3081,7 @@ export class BoatApi extends runtime.BaseAPI {
     }
 
     /**
-     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`).
+     * Stream a single file\'s bytes, or a folder subtree as a tar archive, directly out of a snapshot, the sandbox can be stopped or archived; the machine is never contacted. Use `GET /snapshots/{snapshotId}/tree` to list paths, then pass one here. Paths are relative to the snapshot root (same space as `tree` entries; docker volumes under `__dockervol__/`). An empty or `/` path downloads the whole snapshot as a tar. Folder responses set `X-Snapshot-File-Count`, `X-Snapshot-Total-Size-Bytes` and `X-Snapshot-Skipped-Base-Image-Files` headers; both response shapes set `X-Snapshot-Entry-Kind` (`file` or `dir`). File responses accept a single `Range: bytes=` header and answer 206 with `Content-Range`, so large files can be downloaded in parts and resumed.
      * Download a file or folder from a snapshot
      */
     async getSnapshotFile(requestParameters: GetSnapshotFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob> {
@@ -2779,6 +3207,53 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getTelemetry without sending the request
+     */
+    async getTelemetryRequestOpts(): 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 = `/telemetry`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Returns the account\'s OpenTelemetry export, or `telemetry` null when none is set. Header values are never included. Needs an API key with `account.admin`.
+     * Get OpenTelemetry export
+     */
+    async getTelemetryRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TelemetryResponse>> {
+        const requestOptions = await this.getTelemetryRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TelemetryResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns the account\'s OpenTelemetry export, or `telemetry` null when none is set. Header values are never included. Needs an API key with `account.admin`.
+     * Get OpenTelemetry export
+     */
+    async getTelemetry(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TelemetryResponse> {
+        const response = await this.getTelemetryRaw(initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getWebhook without sending the request
      */
@@ -3387,6 +3862,61 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for processes without sending the request
+     */
+    async processesRequestOpts(requestParameters: ProcessesRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling processes().'
+            );
+        }
+
+        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 = `/sandboxes/{sandboxId}/processes`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * A running sandbox: every user-space process, read now, busiest first. A stopped sandbox: the last sample kept (`live: false`).
+     * List the processes in a sandbox
+     */
+    async processesRaw(requestParameters: ProcessesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProcessListResponse>> {
+        const requestOptions = await this.processesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProcessListResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * A running sandbox: every user-space process, read now, busiest first. A stopped sandbox: the last sample kept (`live: false`).
+     * List the processes in a sandbox
+     */
+    async processes(requestParameters: ProcessesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProcessListResponse> {
+        const response = await this.processesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for prompt without sending the request
      */
@@ -4429,6 +4959,64 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for setTelemetry without sending the request
+     */
+    async setTelemetryRequestOpts(input: SetTelemetryRequest | runtime.FlatBody<SetTelemetryRequest, 'telemetrySetRequest'>): Promise<runtime.RequestOpts> {
+        const requestParameters = runtime.unflattenBody<SetTelemetryRequest>(input, 'telemetrySetRequest', [], []);
+        if (requestParameters['telemetrySetRequest'] == null) {
+            throw new runtime.RequiredError(
+                'telemetrySetRequest',
+                'Required parameter "telemetrySetRequest" was null or undefined when calling setTelemetry().'
+            );
+        }
+
+        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 = `/telemetry`;
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: TelemetrySetRequestToJSON(requestParameters['telemetrySetRequest']),
+        };
+    }
+
+    /**
+     * Sets the account\'s one OTLP/HTTP destination, or replaces it. Boat then sends one metrics export at once and returns the collector\'s answer in `test`.  Every 60 seconds Boat sends the sandbox and account gauges to `<endpoint>/v1/metrics`. Each sandbox lifecycle event goes to `<endpoint>/v1/logs`. The endpoint must use HTTPS on port 443 or 4318 and resolve only to public addresses. Needs an API key with `account.admin`. 
+     * Set OpenTelemetry export
+     */
+    async setTelemetryRaw(requestParameters: SetTelemetryRequest | runtime.FlatBody<SetTelemetryRequest, 'telemetrySetRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TelemetrySetResponse>> {
+        const requestOptions = await this.setTelemetryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TelemetrySetResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Sets the account\'s one OTLP/HTTP destination, or replaces it. Boat then sends one metrics export at once and returns the collector\'s answer in `test`.  Every 60 seconds Boat sends the sandbox and account gauges to `<endpoint>/v1/metrics`. Each sandbox lifecycle event goes to `<endpoint>/v1/logs`. The endpoint must use HTTPS on port 443 or 4318 and resolve only to public addresses. Needs an API key with `account.admin`. 
+     * Set OpenTelemetry export
+     */
+    async setTelemetry(requestParameters: SetTelemetryRequest | runtime.FlatBody<SetTelemetryRequest, 'telemetrySetRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TelemetrySetResponse> {
+        const response = await this.setTelemetryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for share without sending the request
      */
@@ -4679,6 +5267,69 @@ export class BoatApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for stopCommand without sending the request
+     */
+    async stopCommandRequestOpts(requestParameters: StopCommandRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError(
+                'sandboxId',
+                'Required parameter "sandboxId" was null or undefined when calling stopCommand().'
+            );
+        }
+
+        if (requestParameters['processId'] == null) {
+            throw new runtime.RequiredError(
+                'processId',
+                'Required parameter "processId" was null or undefined when calling stopCommand().'
+            );
+        }
+
+        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 = `/sandboxes/{sandboxId}/commands/{processId}`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{processId}', encodeURIComponent(String(requestParameters['processId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Sends SIGTERM to the command and every process it started, then SIGKILL to what is left after 5 s. Only a process started with `detached` can be stopped. The response carries the command\'s history record with its final state and output.
+     * Stop a detached command
+     */
+    async stopCommandRaw(requestParameters: StopCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CommandStopResponse>> {
+        const requestOptions = await this.stopCommandRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CommandStopResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Sends SIGTERM to the command and every process it started, then SIGKILL to what is left after 5 s. Only a process started with `detached` can be stopped. The response carries the command\'s history record with its final state and output.
+     * Stop a detached command
+     */
+    async stopCommand(requestParameters: StopCommandRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CommandStopResponse> {
+        const response = await this.stopCommandRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for update without sending the request
      */
@@ -5179,6 +5830,22 @@ export class BoatApi extends runtime.BaseAPI {
 
 }
 
+/**
+ * @export
+ */
+export const CommandLogsStreamEnum = {
+    Stdout: 'stdout',
+    Stderr: 'stderr'
+} as const;
+export type CommandLogsStreamEnum = typeof CommandLogsStreamEnum[keyof typeof CommandLogsStreamEnum];
+/**
+ * @export
+ */
+export const CommandLogsEncodingEnum = {
+    Utf8: 'utf8',
+    Base64: 'base64'
+} as const;
+export type CommandLogsEncodingEnum = typeof CommandLogsEncodingEnum[keyof typeof CommandLogsEncodingEnum];
 /**
  * @export
  */