@boatdev/sdk 1.0.0

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

@@ -0,0 +1 @@
+export * from './BoatApi';

package/dist/esm/apis/index.js

@@ -0,0 +1,3 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './BoatApi';

package/dist/esm/boat-helpers.d.ts

@@ -0,0 +1,56 @@
+import { BoatApi } from './apis/BoatApi';
+import type { Sandbox, SandboxEvent, DesktopResponse, PromptRequest, PromptRun } from './models';
+export type WaitOptions = {
+    timeoutMs?: number;
+    intervalMs?: number;
+};
+export type StreamEventsOptions = WaitOptions & {
+    type?: string;
+    limit?: number;
+    includeExisting?: boolean;
+    signal?: AbortSignal;
+};
+export type StreamPromptOptions = WaitOptions & {
+    signal?: AbortSignal;
+};
+export declare function waitUntilReady(api: BoatApi, sandboxId: string, options?: WaitOptions): Promise<Sandbox>;
+export declare function waitUntilIdle(api: BoatApi, sandboxId: string, options?: WaitOptions): Promise<Sandbox>;
+export declare function waitForDesktop(api: BoatApi, sandboxId: string, options?: WaitOptions & {
+    vnc?: number;
+    publicAccess?: boolean;
+}): Promise<DesktopResponse>;
+export declare function waitForPrompt(api: BoatApi, sandboxId: string, promptId: string, options?: WaitOptions): Promise<PromptRun>;
+export declare const waitForPromptDone: typeof waitForPrompt;
+/**
+ * Long-poll sandbox events and yield each new event once.
+ *
+ * The v1 API does not require a separate SSE/WebSocket connection. This helper
+ * polls `events({ sort: "asc" })`, advances a cursor after every event, and
+ * yields response events as soon as they are persisted. Streaming response
+ * partials have `event.data.isStreaming === true` (or `is_streaming` in raw
+ * JSON); tool-call events are response events whose `event.data.tools` array is
+ * present.
+ */
+export declare function streamEvents(api: BoatApi, sandboxId: string, options?: StreamEventsOptions): AsyncGenerator<SandboxEvent>;
+/**
+ * Queue a prompt, then yield its prompt/response/tool events until the prompt
+ * reaches `finished` or `failed`.
+ */
+export declare function streamPrompt(api: BoatApi, sandboxId: string, promptRequest: PromptRequest, options?: StreamPromptOptions): AsyncGenerator<SandboxEvent>;
+/**
+ * Stop a sandbox, or delete it outright.
+ *
+ * The default stops the sandbox and keeps its snapshots, so it can be resumed or
+ * forked later. `options.delete` is irreversible: the sandbox is force-stopped
+ * without a final snapshot and every snapshot chain only it uses is deleted.
+ *
+ * The generated method is `deleteSandbox`, not `delete` -- `delete` is a reserved
+ * word the generators rename, and calling a method the SDK does not actually
+ * expose is what broke the TypeScript build (TS2339) and stopped it publishing.
+ */
+export declare function stopAndRemove(api: BoatApi, sandboxId: string, options?: {
+    delete?: boolean;
+}): Promise<import("./models").DeletionOperationResponse | import("./models").SandboxActionResponse>;
+export declare function readText(api: BoatApi, sandboxId: string, path: string): Promise<string>;
+export declare function writeText(api: BoatApi, sandboxId: string, path: string, content: string): Promise<import("./models").FileWriteResponse>;
+export declare function execCommand(api: BoatApi, sandboxId: string, command: string, cwd?: string, timeoutSeconds?: number): Promise<import("./models").Command200Response>;

package/dist/esm/boat-helpers.js

@@ -0,0 +1,163 @@
+const terminalPromptStatuses = new Set(['finished', 'failed']);
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function poll(options, fn) {
+    var _a, _b;
+    const timeoutMs = (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : 300000;
+    const intervalMs = (_b = options === null || options === void 0 ? void 0 : options.intervalMs) !== null && _b !== void 0 ? _b : 2000;
+    const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+    for (;;) {
+        const value = await fn();
+        if (value !== undefined)
+            return value;
+        if (Date.now() >= deadline)
+            throw new Error('Timed out waiting for sandbox state');
+        await delay(intervalMs);
+    }
+}
+export async function waitUntilReady(api, sandboxId, options) {
+    return poll(options, async () => {
+        const sandbox = (await api.get({ sandboxId })).sandbox;
+        if (['ready', 'idle', 'running'].indexOf(sandbox.state) !== -1)
+            return sandbox;
+        if (['archived', 'archiving', 'error'].indexOf(sandbox.state) !== -1)
+            throw new Error(`Sandbox entered terminal state ${sandbox.state}`);
+        return undefined;
+    });
+}
+export async function waitUntilIdle(api, sandboxId, options) {
+    return poll({ timeoutMs: 600000, intervalMs: 2000, ...options }, async () => {
+        const sandbox = (await api.get({ sandboxId })).sandbox;
+        if (sandbox.state === 'idle')
+            return sandbox;
+        if (['archived', 'archiving', 'error'].indexOf(sandbox.state) !== -1)
+            throw new Error(`Sandbox entered terminal state ${sandbox.state}`);
+        return undefined;
+    });
+}
+export async function waitForDesktop(api, sandboxId, options) {
+    return poll(options, async () => {
+        var _a;
+        const desktopRequest = (options === null || options === void 0 ? void 0 : options.publicAccess) ? { publicAccess: true } : {};
+        const desktop = await api.desktop({ sandboxId, vnc: ((_a = options === null || options === void 0 ? void 0 : options.vnc) !== null && _a !== void 0 ? _a : 1), desktopRequest });
+        return desktop.desktopUrl && !desktop.provisioning ? desktop : undefined;
+    });
+}
+export async function waitForPrompt(api, sandboxId, promptId, options) {
+    return poll({ timeoutMs: 1800000, intervalMs: 2000, ...options }, async () => {
+        const run = (await api.promptRunStatus({ sandboxId, promptId })).promptRun;
+        return terminalPromptStatuses.has(run.status) ? run : undefined;
+    });
+}
+export const waitForPromptDone = waitForPrompt;
+function encodeCursor(event) {
+    const raw = `${event.timestamp}:${event.id}`;
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor)
+        return bufferCtor.from(raw, 'utf8').toString('base64url');
+    return btoa(raw).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+function eventStatus(event) {
+    const data = event.data;
+    return typeof (data === null || data === void 0 ? void 0 : data.status) === 'string' ? data.status : undefined;
+}
+function throwIfAborted(signal) {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+        throw new Error('Sandbox event stream aborted');
+}
+/**
+ * Long-poll sandbox events and yield each new event once.
+ *
+ * The v1 API does not require a separate SSE/WebSocket connection. This helper
+ * polls `events({ sort: "asc" })`, advances a cursor after every event, and
+ * yields response events as soon as they are persisted. Streaming response
+ * partials have `event.data.isStreaming === true` (or `is_streaming` in raw
+ * JSON); tool-call events are response events whose `event.data.tools` array is
+ * present.
+ */
+export async function* streamEvents(api, sandboxId, options) {
+    var _a, _b, _c, _d, _e;
+    const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 100;
+    const intervalMs = (_b = options === null || options === void 0 ? void 0 : options.intervalMs) !== null && _b !== void 0 ? _b : 1000;
+    const timeoutMs = (_c = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _c !== void 0 ? _c : 0;
+    const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+    let cursor;
+    if (!(options === null || options === void 0 ? void 0 : options.includeExisting)) {
+        const existing = (_d = (await api.events({ sandboxId, limit: 200, sort: 'asc', type: options === null || options === void 0 ? void 0 : options.type })).events) !== null && _d !== void 0 ? _d : [];
+        const last = existing[existing.length - 1];
+        if ((last === null || last === void 0 ? void 0 : last.id) && (last === null || last === void 0 ? void 0 : last.timestamp))
+            cursor = encodeCursor(last);
+    }
+    for (;;) {
+        throwIfAborted(options === null || options === void 0 ? void 0 : options.signal);
+        const page = await api.events({ sandboxId, limit, cursor, sort: 'asc', type: options === null || options === void 0 ? void 0 : options.type });
+        for (const event of (_e = page.events) !== null && _e !== void 0 ? _e : []) {
+            cursor = encodeCursor(event);
+            yield event;
+        }
+        if (Date.now() >= deadline)
+            throw new Error('Timed out streaming sandbox events');
+        await delay(intervalMs);
+    }
+}
+/**
+ * Queue a prompt, then yield its prompt/response/tool events until the prompt
+ * reaches `finished` or `failed`.
+ */
+export async function* streamPrompt(api, sandboxId, promptRequest, options) {
+    var _a, _b, _c, _d, _e;
+    const existing = (_a = (await api.events({ sandboxId, limit: 200, sort: 'asc' })).events) !== null && _a !== void 0 ? _a : [];
+    let cursor;
+    const last = existing[existing.length - 1];
+    if ((last === null || last === void 0 ? void 0 : last.id) && (last === null || last === void 0 ? void 0 : last.timestamp))
+        cursor = encodeCursor(last);
+    const response = await api.prompt({ sandboxId, promptRequest });
+    const promptId = response.promptId;
+    const intervalMs = (_b = options === null || options === void 0 ? void 0 : options.intervalMs) !== null && _b !== void 0 ? _b : 1000;
+    const timeoutMs = (_c = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _c !== void 0 ? _c : 1800000;
+    const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+    for (;;) {
+        throwIfAborted(options === null || options === void 0 ? void 0 : options.signal);
+        const page = await api.events({ sandboxId, limit: 100, cursor, sort: 'asc', type: 'prompt,response,usage_limit,shield' });
+        for (const event of (_d = page.events) !== null && _d !== void 0 ? _d : []) {
+            cursor = encodeCursor(event);
+            if (event.taskId !== promptId)
+                continue;
+            yield event;
+            if (event.type === 'prompt' && terminalPromptStatuses.has((_e = eventStatus(event)) !== null && _e !== void 0 ? _e : ''))
+                return;
+        }
+        const run = (await api.promptRunStatus({ sandboxId, promptId })).promptRun;
+        if (terminalPromptStatuses.has(run.status))
+            return;
+        if (Date.now() >= deadline)
+            throw new Error('Timed out streaming prompt events');
+        await delay(intervalMs);
+    }
+}
+/**
+ * Stop a sandbox, or delete it outright.
+ *
+ * The default stops the sandbox and keeps its snapshots, so it can be resumed or
+ * forked later. `options.delete` is irreversible: the sandbox is force-stopped
+ * without a final snapshot and every snapshot chain only it uses is deleted.
+ *
+ * The generated method is `deleteSandbox`, not `delete` -- `delete` is a reserved
+ * word the generators rename, and calling a method the SDK does not actually
+ * expose is what broke the TypeScript build (TS2339) and stopped it publishing.
+ */
+export async function stopAndRemove(api, sandboxId, options) {
+    if (options === null || options === void 0 ? void 0 : options.delete)
+        return api.deleteSandbox({ sandboxId, xAsciiConfirmDelete: sandboxId });
+    return api.stop({ sandboxId });
+}
+export async function readText(api, sandboxId, path) {
+    return (await api.readFile({ sandboxId, path, encoding: 'utf8' })).content;
+}
+export async function writeText(api, sandboxId, path, content) {
+    return api.writeFile({ sandboxId, fileWriteRequest: { path, content, encoding: 'utf8' } });
+}
+export async function execCommand(api, sandboxId, command, cwd, timeoutSeconds = 30) {
+    return api.command({ sandboxId, commandRequest: { command, cwd, timeoutSeconds } });
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './runtime';
+export * from './apis/index';
+export * from './models/index';
+export * from './boat-helpers';

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './runtime';
+export * from './apis/index';
+export * from './models/index';
+export * from './boat-helpers';

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

@@ -0,0 +1,38 @@
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface AddEnvironmentRepoRequest
+ */
+export interface AddEnvironmentRepoRequest {
+    /**
+     * The repository `databaseId` from `GET /repos`.
+     * @type {string}
+     * @memberof AddEnvironmentRepoRequest
+     */
+    repositoryId: string;
+    /**
+     *
+     * @type {string}
+     * @memberof AddEnvironmentRepoRequest
+     */
+    baseBranch?: string;
+}
+/**
+ * Check if a given object implements the AddEnvironmentRepoRequest interface.
+ */
+export declare function instanceOfAddEnvironmentRepoRequest(value: object): value is AddEnvironmentRepoRequest;
+export declare function AddEnvironmentRepoRequestFromJSON(json: any): AddEnvironmentRepoRequest;
+export declare function AddEnvironmentRepoRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): AddEnvironmentRepoRequest;
+export declare function AddEnvironmentRepoRequestToJSON(json: any): AddEnvironmentRepoRequest;
+export declare function AddEnvironmentRepoRequestToJSONTyped(value?: AddEnvironmentRepoRequest | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/AddEnvironmentRepoRequest.js

@@ -0,0 +1,45 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Check if a given object implements the AddEnvironmentRepoRequest interface.
+ */
+export function instanceOfAddEnvironmentRepoRequest(value) {
+    if (!('repositoryId' in value) || value['repositoryId'] === undefined)
+        return false;
+    return true;
+}
+export function AddEnvironmentRepoRequestFromJSON(json) {
+    return AddEnvironmentRepoRequestFromJSONTyped(json, false);
+}
+export function AddEnvironmentRepoRequestFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'repositoryId': json['repositoryId'],
+        'baseBranch': json['baseBranch'] == null ? undefined : json['baseBranch'],
+    };
+}
+export function AddEnvironmentRepoRequestToJSON(json) {
+    return AddEnvironmentRepoRequestToJSONTyped(json, false);
+}
+export function AddEnvironmentRepoRequestToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'repositoryId': value['repositoryId'],
+        'baseBranch': value['baseBranch'],
+    };
+}

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

@@ -0,0 +1,121 @@
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ApiKeyScope } from './ApiKeyScope';
+import type { ApiKeyRequestUsage } from './ApiKeyRequestUsage';
+import type { ApiKeyResourceTotals } from './ApiKeyResourceTotals';
+/**
+ *
+ * @export
+ * @interface ApiKey
+ */
+export interface ApiKey {
+    /**
+     *
+     * @type {string}
+     * @memberof ApiKey
+     */
+    id: string;
+    /**
+     *
+     * @type {string}
+     * @memberof ApiKey
+     */
+    name: string;
+    /**
+     * Credential storage lane. Scoped secrets are never stored in the legacy hash column.
+     * @type {ApiKeyCredentialLaneEnum}
+     * @memberof ApiKey
+     */
+    credentialLane: ApiKeyCredentialLaneEnum;
+    /**
+     *
+     * @type {string}
+     * @memberof ApiKey
+     */
+    keyPrefix: string;
+    /**
+     *
+     * @type {string}
+     * @memberof ApiKey
+     */
+    keyLastFour: string;
+    /**
+     * Sandbox ID for a platform-managed machine key, or null for a user-created key.
+     * @type {string}
+     * @memberof ApiKey
+     */
+    sandboxId: string | null;
+    /**
+     *
+     * @type {Date}
+     * @memberof ApiKey
+     */
+    createdAt: Date;
+    /**
+     *
+     * @type {Date}
+     * @memberof ApiKey
+     */
+    lastUsedAt: Date | null;
+    /**
+     *
+     * @type {ApiKeyRequestUsage}
+     * @memberof ApiKey
+     */
+    usage: ApiKeyRequestUsage;
+    /**
+     *
+     * @type {ApiKeyResourceTotals}
+     * @memberof ApiKey
+     */
+    resources: ApiKeyResourceTotals;
+    /**
+     *
+     * @type {Date}
+     * @memberof ApiKey
+     */
+    expiresAt?: Date | null;
+    /**
+     *
+     * @type {boolean}
+     * @memberof ApiKey
+     */
+    expired?: boolean;
+    /**
+     *
+     * @type {boolean}
+     * @memberof ApiKey
+     */
+    expiringSoon?: boolean;
+    /**
+     *
+     * @type {ApiKeyScope}
+     * @memberof ApiKey
+     */
+    scope?: ApiKeyScope;
+}
+/**
+ * @export
+ */
+export declare const ApiKeyCredentialLaneEnum: {
+    readonly Legacy: 'legacy';
+    readonly ScopedV1: 'scoped-v1';
+};
+export type ApiKeyCredentialLaneEnum = typeof ApiKeyCredentialLaneEnum[keyof typeof ApiKeyCredentialLaneEnum];
+/**
+ * Check if a given object implements the ApiKey interface.
+ */
+export declare function instanceOfApiKey(value: object): value is ApiKey;
+export declare function ApiKeyFromJSON(json: any): ApiKey;
+export declare function ApiKeyFromJSONTyped(json: any, ignoreDiscriminator: boolean): ApiKey;
+export declare function ApiKeyToJSON(json: any): ApiKey;
+export declare function ApiKeyToJSONTyped(value?: ApiKey | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/ApiKey.js

@@ -0,0 +1,97 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { ApiKeyScopeFromJSON, ApiKeyScopeToJSON, } from './ApiKeyScope';
+import { ApiKeyRequestUsageFromJSON, ApiKeyRequestUsageToJSON, } from './ApiKeyRequestUsage';
+import { ApiKeyResourceTotalsFromJSON, ApiKeyResourceTotalsToJSON, } from './ApiKeyResourceTotals';
+/**
+ * @export
+ */
+export const ApiKeyCredentialLaneEnum = {
+    Legacy: 'legacy',
+    ScopedV1: 'scoped-v1'
+};
+/**
+ * Check if a given object implements the ApiKey interface.
+ */
+export function instanceOfApiKey(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('name' in value) || value['name'] === undefined)
+        return false;
+    if (!('credentialLane' in value) || value['credentialLane'] === undefined)
+        return false;
+    if (!('keyPrefix' in value) || value['keyPrefix'] === undefined)
+        return false;
+    if (!('keyLastFour' in value) || value['keyLastFour'] === undefined)
+        return false;
+    if (!('sandboxId' in value) || value['sandboxId'] === undefined)
+        return false;
+    if (!('createdAt' in value) || value['createdAt'] === undefined)
+        return false;
+    if (!('lastUsedAt' in value) || value['lastUsedAt'] === undefined)
+        return false;
+    if (!('usage' in value) || value['usage'] === undefined)
+        return false;
+    if (!('resources' in value) || value['resources'] === undefined)
+        return false;
+    return true;
+}
+export function ApiKeyFromJSON(json) {
+    return ApiKeyFromJSONTyped(json, false);
+}
+export function ApiKeyFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'name': json['name'],
+        'credentialLane': json['credentialLane'],
+        'keyPrefix': json['keyPrefix'],
+        'keyLastFour': json['keyLastFour'],
+        'sandboxId': json['sandboxId'],
+        'createdAt': (new Date(json['createdAt'])),
+        'lastUsedAt': (json['lastUsedAt'] == null ? null : new Date(json['lastUsedAt'])),
+        'usage': ApiKeyRequestUsageFromJSON(json['usage']),
+        'resources': ApiKeyResourceTotalsFromJSON(json['resources']),
+        'expiresAt': json['expiresAt'] == null ? undefined : (new Date(json['expiresAt'])),
+        'expired': json['expired'] == null ? undefined : json['expired'],
+        'expiringSoon': json['expiringSoon'] == null ? undefined : json['expiringSoon'],
+        'scope': json['scope'] == null ? undefined : ApiKeyScopeFromJSON(json['scope']),
+    };
+}
+export function ApiKeyToJSON(json) {
+    return ApiKeyToJSONTyped(json, false);
+}
+export function ApiKeyToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'name': value['name'],
+        'credentialLane': value['credentialLane'],
+        'keyPrefix': value['keyPrefix'],
+        'keyLastFour': value['keyLastFour'],
+        'sandboxId': value['sandboxId'],
+        'createdAt': value['createdAt'].toISOString(),
+        'lastUsedAt': value['lastUsedAt'] == null ? value['lastUsedAt'] : value['lastUsedAt'].toISOString(),
+        'usage': ApiKeyRequestUsageToJSON(value['usage']),
+        'resources': ApiKeyResourceTotalsToJSON(value['resources']),
+        'expiresAt': value['expiresAt'] == null ? value['expiresAt'] : value['expiresAt'].toISOString(),
+        'expired': value['expired'],
+        'expiringSoon': value['expiringSoon'],
+        'scope': ApiKeyScopeToJSON(value['scope']),
+    };
+}

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

@@ -0,0 +1,65 @@
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ApiKeyCatalogScopeResources } from './ApiKeyCatalogScopeResources';
+/**
+ *
+ * @export
+ * @interface ApiKeyCatalog
+ */
+export interface ApiKeyCatalog {
+    /**
+     *
+     * @type {Array<string>}
+     * @memberof ApiKeyCatalog
+     */
+    actions: Array<string>;
+    /**
+     *
+     * @type {{ [key: string]: Array<string>; }}
+     * @memberof ApiKeyCatalog
+     */
+    presets: {
+        [key: string]: Array<string>;
+    };
+    /**
+     *
+     * @type {string}
+     * @memberof ApiKeyCatalog
+     */
+    defaultTtl: string;
+    /**
+     *
+     * @type {string}
+     * @memberof ApiKeyCatalog
+     */
+    maxTtl: string;
+    /**
+     * Whether POST /api-keys/scoped currently accepts creation requests.
+     * @type {boolean}
+     * @memberof ApiKeyCatalog
+     */
+    scopedCreationEnabled: boolean;
+    /**
+     *
+     * @type {ApiKeyCatalogScopeResources}
+     * @memberof ApiKeyCatalog
+     */
+    scopeResources?: ApiKeyCatalogScopeResources;
+}
+/**
+ * Check if a given object implements the ApiKeyCatalog interface.
+ */
+export declare function instanceOfApiKeyCatalog(value: object): value is ApiKeyCatalog;
+export declare function ApiKeyCatalogFromJSON(json: any): ApiKeyCatalog;
+export declare function ApiKeyCatalogFromJSONTyped(json: any, ignoreDiscriminator: boolean): ApiKeyCatalog;
+export declare function ApiKeyCatalogToJSON(json: any): ApiKeyCatalog;
+export declare function ApiKeyCatalogToJSONTyped(value?: ApiKeyCatalog | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/ApiKeyCatalog.js

@@ -0,0 +1,62 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { ApiKeyCatalogScopeResourcesFromJSON, ApiKeyCatalogScopeResourcesToJSON, } from './ApiKeyCatalogScopeResources';
+/**
+ * Check if a given object implements the ApiKeyCatalog interface.
+ */
+export function instanceOfApiKeyCatalog(value) {
+    if (!('actions' in value) || value['actions'] === undefined)
+        return false;
+    if (!('presets' in value) || value['presets'] === undefined)
+        return false;
+    if (!('defaultTtl' in value) || value['defaultTtl'] === undefined)
+        return false;
+    if (!('maxTtl' in value) || value['maxTtl'] === undefined)
+        return false;
+    if (!('scopedCreationEnabled' in value) || value['scopedCreationEnabled'] === undefined)
+        return false;
+    return true;
+}
+export function ApiKeyCatalogFromJSON(json) {
+    return ApiKeyCatalogFromJSONTyped(json, false);
+}
+export function ApiKeyCatalogFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'actions': json['actions'],
+        'presets': json['presets'],
+        'defaultTtl': json['defaultTtl'],
+        'maxTtl': json['maxTtl'],
+        'scopedCreationEnabled': json['scopedCreationEnabled'],
+        'scopeResources': json['scopeResources'] == null ? undefined : ApiKeyCatalogScopeResourcesFromJSON(json['scopeResources']),
+    };
+}
+export function ApiKeyCatalogToJSON(json) {
+    return ApiKeyCatalogToJSONTyped(json, false);
+}
+export function ApiKeyCatalogToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'actions': value['actions'],
+        'presets': value['presets'],
+        'defaultTtl': value['defaultTtl'],
+        'maxTtl': value['maxTtl'],
+        'scopedCreationEnabled': value['scopedCreationEnabled'],
+        'scopeResources': ApiKeyCatalogScopeResourcesToJSON(value['scopeResources']),
+    };
+}