@boatdev/sdk 1.0.0

package/src/apis/index.ts

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

package/src/boat-helpers.ts

@@ -0,0 +1,187 @@
+
+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;
+};
+
+const terminalPromptStatuses = new Set(['finished', 'failed']);
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function poll<T>(options: WaitOptions | undefined, fn: () => Promise<T | undefined>): Promise<T> {
+  const timeoutMs = options?.timeoutMs ?? 300_000;
+  const intervalMs = options?.intervalMs ?? 2_000;
+  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: BoatApi, sandboxId: string, options?: WaitOptions): Promise<Sandbox> {
+  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: BoatApi, sandboxId: string, options?: WaitOptions): Promise<Sandbox> {
+  return poll({ timeoutMs: 600_000, intervalMs: 2_000, ...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: BoatApi, sandboxId: string, options?: WaitOptions & { vnc?: number; publicAccess?: boolean }): Promise<DesktopResponse> {
+  return poll(options, async () => {
+    const desktopRequest = options?.publicAccess ? { publicAccess: true } : {};
+    const desktop = await api.desktop({ sandboxId, vnc: (options?.vnc ?? 1) as 1, desktopRequest });
+    return desktop.desktopUrl && !desktop.provisioning ? desktop : undefined;
+  });
+}
+
+export async function waitForPrompt(api: BoatApi, sandboxId: string, promptId: string, options?: WaitOptions): Promise<PromptRun> {
+  return poll({ timeoutMs: 1_800_000, intervalMs: 2_000, ...options }, async () => {
+    const run = (await api.promptRunStatus({ sandboxId, promptId })).promptRun;
+    return terminalPromptStatuses.has(run.status) ? run : undefined;
+  });
+}
+
+export const waitForPromptDone = waitForPrompt;
+
+function encodeCursor(event: { timestamp?: number; id?: string }): string {
+  const raw = `${event.timestamp}:${event.id}`;
+  const bufferCtor = (globalThis as any).Buffer;
+  if (bufferCtor) return bufferCtor.from(raw, 'utf8').toString('base64url');
+  return btoa(raw).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+
+function eventStatus(event: SandboxEvent): string | undefined {
+  const data = (event as any).data;
+  return typeof data?.status === 'string' ? data.status : undefined;
+}
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (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: BoatApi, sandboxId: string, options?: StreamEventsOptions): AsyncGenerator<SandboxEvent> {
+  const limit = options?.limit ?? 100;
+  const intervalMs = options?.intervalMs ?? 1_000;
+  const timeoutMs = options?.timeoutMs ?? 0;
+  const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  let cursor: string | undefined;
+
+  if (!options?.includeExisting) {
+    const existing = (await api.events({ sandboxId, limit: 200, sort: 'asc', type: options?.type })).events ?? [];
+    const last = existing[existing.length - 1] as any;
+    if (last?.id && last?.timestamp) cursor = encodeCursor(last);
+  }
+
+  for (;;) {
+    throwIfAborted(options?.signal);
+    const page = await api.events({ sandboxId, limit, cursor, sort: 'asc', type: options?.type });
+    for (const event of page.events ?? []) {
+      cursor = encodeCursor(event as any);
+      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: BoatApi,
+  sandboxId: string,
+  promptRequest: PromptRequest,
+  options?: StreamPromptOptions,
+): AsyncGenerator<SandboxEvent> {
+  const existing = (await api.events({ sandboxId, limit: 200, sort: 'asc' })).events ?? [];
+  let cursor: string | undefined;
+  const last = existing[existing.length - 1] as any;
+  if (last?.id && last?.timestamp) cursor = encodeCursor(last);
+
+  const response = await api.prompt({ sandboxId, promptRequest });
+  const promptId = response.promptId;
+  const intervalMs = options?.intervalMs ?? 1_000;
+  const timeoutMs = options?.timeoutMs ?? 1_800_000;
+  const deadline = timeoutMs === 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  for (;;) {
+    throwIfAborted(options?.signal);
+    const page = await api.events({ sandboxId, limit: 100, cursor, sort: 'asc', type: 'prompt,response,usage_limit,shield' });
+    for (const event of page.events ?? []) {
+      cursor = encodeCursor(event as any);
+      if ((event as any).taskId !== promptId) continue;
+      yield event;
+      if (event.type === 'prompt' && terminalPromptStatuses.has(eventStatus(event) ?? '')) 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: BoatApi, sandboxId: string, options?: { delete?: boolean }) {
+  if (options?.delete) return api.deleteSandbox({ sandboxId, xAsciiConfirmDelete: sandboxId });
+  return api.stop({ sandboxId });
+}
+
+export async function readText(api: BoatApi, sandboxId: string, path: string): Promise<string> {
+  return (await api.readFile({ sandboxId, path, encoding: 'utf8' })).content;
+}
+
+export async function writeText(api: BoatApi, sandboxId: string, path: string, content: string) {
+  return api.writeFile({ sandboxId, fileWriteRequest: { path, content, encoding: 'utf8' } });
+}
+
+export async function execCommand(api: BoatApi, sandboxId: string, command: string, cwd?: string, timeoutSeconds = 30) {
+  return api.command({ sandboxId, commandRequest: { command, cwd, timeoutSeconds } });
+}

package/src/index.ts

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

package/src/models/AddEnvironmentRepoRequest.ts

@@ -0,0 +1,74 @@
+/* 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 { mapValues } from '../runtime';
+/**
+ * 
+ * @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 function instanceOfAddEnvironmentRepoRequest(value: object): value is AddEnvironmentRepoRequest {
+    if (!('repositoryId' in value) || value['repositoryId'] === undefined) return false;
+    return true;
+}
+
+export function AddEnvironmentRepoRequestFromJSON(json: any): AddEnvironmentRepoRequest {
+    return AddEnvironmentRepoRequestFromJSONTyped(json, false);
+}
+
+export function AddEnvironmentRepoRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): AddEnvironmentRepoRequest {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'repositoryId': json['repositoryId'],
+        'baseBranch': json['baseBranch'] == null ? undefined : json['baseBranch'],
+    };
+}
+
+export function AddEnvironmentRepoRequestToJSON(json: any): AddEnvironmentRepoRequest {
+    return AddEnvironmentRepoRequestToJSONTyped(json, false);
+}
+
+export function AddEnvironmentRepoRequestToJSONTyped(value?: AddEnvironmentRepoRequest | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'repositoryId': value['repositoryId'],
+        'baseBranch': value['baseBranch'],
+    };
+}
+

package/src/models/ApiKey.ts

@@ -0,0 +1,212 @@
+/* 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 { mapValues } from '../runtime';
+import type { ApiKeyScope } from './ApiKeyScope';
+import {
+    ApiKeyScopeFromJSON,
+    ApiKeyScopeFromJSONTyped,
+    ApiKeyScopeToJSON,
+    ApiKeyScopeToJSONTyped,
+} from './ApiKeyScope';
+import type { ApiKeyRequestUsage } from './ApiKeyRequestUsage';
+import {
+    ApiKeyRequestUsageFromJSON,
+    ApiKeyRequestUsageFromJSONTyped,
+    ApiKeyRequestUsageToJSON,
+    ApiKeyRequestUsageToJSONTyped,
+} from './ApiKeyRequestUsage';
+import type { ApiKeyResourceTotals } from './ApiKeyResourceTotals';
+import {
+    ApiKeyResourceTotalsFromJSON,
+    ApiKeyResourceTotalsFromJSONTyped,
+    ApiKeyResourceTotalsToJSON,
+    ApiKeyResourceTotalsToJSONTyped,
+} 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 const ApiKeyCredentialLaneEnum = {
+    Legacy: 'legacy',
+    ScopedV1: 'scoped-v1'
+} as const;
+export type ApiKeyCredentialLaneEnum = typeof ApiKeyCredentialLaneEnum[keyof typeof ApiKeyCredentialLaneEnum];
+
+
+/**
+ * Check if a given object implements the ApiKey interface.
+ */
+export function instanceOfApiKey(value: object): value is ApiKey {
+    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: any): ApiKey {
+    return ApiKeyFromJSONTyped(json, false);
+}
+
+export function ApiKeyFromJSONTyped(json: any, ignoreDiscriminator: boolean): ApiKey {
+    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: any): ApiKey {
+    return ApiKeyToJSONTyped(json, false);
+}
+
+export function ApiKeyToJSONTyped(value?: ApiKey | null, ignoreDiscriminator: boolean = false): any {
+    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/src/models/ApiKeyCatalog.ts

@@ -0,0 +1,118 @@
+/* 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 { mapValues } from '../runtime';
+import type { ApiKeyCatalogScopeResources } from './ApiKeyCatalogScopeResources';
+import {
+    ApiKeyCatalogScopeResourcesFromJSON,
+    ApiKeyCatalogScopeResourcesFromJSONTyped,
+    ApiKeyCatalogScopeResourcesToJSON,
+    ApiKeyCatalogScopeResourcesToJSONTyped,
+} 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 function instanceOfApiKeyCatalog(value: object): value is ApiKeyCatalog {
+    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: any): ApiKeyCatalog {
+    return ApiKeyCatalogFromJSONTyped(json, false);
+}
+
+export function ApiKeyCatalogFromJSONTyped(json: any, ignoreDiscriminator: boolean): ApiKeyCatalog {
+    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: any): ApiKeyCatalog {
+    return ApiKeyCatalogToJSONTyped(json, false);
+}
+
+export function ApiKeyCatalogToJSONTyped(value?: ApiKeyCatalog | null, ignoreDiscriminator: boolean = false): any {
+    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']),
+    };
+}
+

package/src/models/ApiKeyCatalogScopeResources.ts

@@ -0,0 +1,83 @@
+/* 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 { mapValues } from '../runtime';
+import type { ApiKeyScopeResource } from './ApiKeyScopeResource';
+import {
+    ApiKeyScopeResourceFromJSON,
+    ApiKeyScopeResourceFromJSONTyped,
+    ApiKeyScopeResourceToJSON,
+    ApiKeyScopeResourceToJSONTyped,
+} from './ApiKeyScopeResource';
+
+/**
+ * Session-only selector resources. Omitted when the caller authenticates with an API key.
+ * @export
+ * @interface ApiKeyCatalogScopeResources
+ */
+export interface ApiKeyCatalogScopeResources {
+    /**
+     * 
+     * @type {Array<ApiKeyScopeResource>}
+     * @memberof ApiKeyCatalogScopeResources
+     */
+    sandboxes: Array<ApiKeyScopeResource>;
+    /**
+     * 
+     * @type {Array<ApiKeyScopeResource>}
+     * @memberof ApiKeyCatalogScopeResources
+     */
+    environments: Array<ApiKeyScopeResource>;
+}
+
+/**
+ * Check if a given object implements the ApiKeyCatalogScopeResources interface.
+ */
+export function instanceOfApiKeyCatalogScopeResources(value: object): value is ApiKeyCatalogScopeResources {
+    if (!('sandboxes' in value) || value['sandboxes'] === undefined) return false;
+    if (!('environments' in value) || value['environments'] === undefined) return false;
+    return true;
+}
+
+export function ApiKeyCatalogScopeResourcesFromJSON(json: any): ApiKeyCatalogScopeResources {
+    return ApiKeyCatalogScopeResourcesFromJSONTyped(json, false);
+}
+
+export function ApiKeyCatalogScopeResourcesFromJSONTyped(json: any, ignoreDiscriminator: boolean): ApiKeyCatalogScopeResources {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'sandboxes': ((json['sandboxes'] as Array<any>).map(ApiKeyScopeResourceFromJSON)),
+        'environments': ((json['environments'] as Array<any>).map(ApiKeyScopeResourceFromJSON)),
+    };
+}
+
+export function ApiKeyCatalogScopeResourcesToJSON(json: any): ApiKeyCatalogScopeResources {
+    return ApiKeyCatalogScopeResourcesToJSONTyped(json, false);
+}
+
+export function ApiKeyCatalogScopeResourcesToJSONTyped(value?: ApiKeyCatalogScopeResources | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'sandboxes': ((value['sandboxes'] as Array<any>).map(ApiKeyScopeResourceToJSON)),
+        'environments': ((value['environments'] as Array<any>).map(ApiKeyScopeResourceToJSON)),
+    };
+}
+