@bctrl/sdk 1.0.3 → 1.0.5

package/dist/runs.js

@@ -1,6 +1,6 @@
+import { v1IdempotencyHeaders } from './http.js';
 import { iterateV1Pages } from './pagination.js';
-import { V1RunFilesClient } from './files.js';
-export class V1RunEventsClient {
+class V1RunEventsClient {
     http;
     runId;
     constructor(http, runId) {
@@ -13,12 +13,6 @@ export class V1RunEventsClient {
     iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-    wait(request) {
-        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/events/wait`, {
-            method: 'POST',
-            body: request ?? {},
-        });
-    }
     streamUrl(query = {}) {
         const url = new URL(`${this.http.baseUrl}/runs/${encodeURIComponent(this.runId)}/events/stream`);
         for (const [key, value] of Object.entries(query)) {
@@ -35,7 +29,7 @@ export class V1RunEventsClient {
         return url.toString();
     }
 }
-export class V1RunCommandsClient {
+class V1RunActivityClient {
     http;
     runId;
     constructor(http, runId) {
@@ -43,63 +37,126 @@ export class V1RunCommandsClient {
         this.runId = runId;
     }
     list(query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/commands`, { query });
+        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/activity`, { query });
     }
     iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
+    streamUrl(query = {}) {
+        const url = new URL(`${this.http.baseUrl}/runs/${encodeURIComponent(this.runId)}/activity/stream`);
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    url.searchParams.append(key, String(item));
+            }
+            else {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
 }
-export class V1RunResource {
+export class V1RunsClient {
     http;
-    data;
     events;
-    commands;
+    activity;
     files;
-    constructor(http, data) {
+    invocations;
+    constructor(http) {
         this.http = http;
-        this.data = data;
-        this.events = new V1RunEventsClient(http, data.id);
-        this.commands = new V1RunCommandsClient(http, data.id);
-        this.files = new V1RunFilesClient(http, data.id);
+        this.events = new V1RunEventsNamespaceClient(http);
+        this.activity = new V1RunActivityNamespaceClient(http);
+        this.files = new V1RunFilesNamespaceClient(http);
+        this.invocations = new V1RunInvocationsNamespaceClient(http);
+    }
+    list(query = {}) {
+        return this.http.request('/runs', { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-    get id() {
-        return this.data.id;
+    get(id) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}`);
     }
-    refresh() {
-        return new V1RunsClient(this.http).get(this.id);
+    usage(id) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
     }
-    live(request) {
-        return this.http.request(`/runs/${encodeURIComponent(this.id)}/live`, {
+    live(id, request) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/live`, {
             method: 'POST',
             body: request ?? {},
         });
     }
-    recording(request) {
-        return this.http.request(`/runs/${encodeURIComponent(this.id)}/recording`, {
+    recording(id, request) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/recording`, {
             method: 'POST',
             body: request ?? {},
         });
     }
-    usage() {
-        return this.http.request(`/runs/${encodeURIComponent(this.id)}/usage`);
+}
+export class V1RunEventsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runId, query = {}) {
+        return new V1RunEventsClient(this.http, runId).list(query);
+    }
+    iter(runId, query = {}) {
+        return new V1RunEventsClient(this.http, runId).iter(query);
+    }
+    streamUrl(runId, query = {}) {
+        return new V1RunEventsClient(this.http, runId).streamUrl(query);
     }
 }
-export class V1RunsClient {
+export class V1RunActivityNamespaceClient {
     http;
     constructor(http) {
         this.http = http;
     }
-    list(query = {}) {
-        return this.http.request('/runs', { query });
+    list(runId, query = {}) {
+        return new V1RunActivityClient(this.http, runId).list(query);
     }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    iter(runId, query = {}) {
+        return new V1RunActivityClient(this.http, runId).iter(query);
     }
-    async get(id) {
-        const run = await this.http.request(`/runs/${encodeURIComponent(id)}`);
-        return new V1RunResource(this.http, run);
+    streamUrl(runId, query = {}) {
+        return new V1RunActivityClient(this.http, runId).streamUrl(query);
     }
-    usage(id) {
-        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
+}
+export class V1RunFilesNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runId, query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/files`, { query });
+    }
+    iter(runId, query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
+    }
+    export(runId, request = {}, options) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/files/export`, {
+            method: 'POST',
+            body: request,
+            headers: v1IdempotencyHeaders(options),
+        });
+    }
+}
+export class V1RunInvocationsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runId, query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/invocations`, { query });
+    }
+    iter(runId, query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
+    }
+    get(runId, invocationId) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/invocations/${encodeURIComponent(invocationId)}`);
     }
 }

package/dist/runtimes.d.ts

@@ -1,69 +1,33 @@
-import type { V1HttpClient } from './http.js';
-import { V1RuntimeInvocationsClient } from './invocations.js';
-import { V1RunResource } from './runs.js';
-import type { V1ListEnvelope, V1File, V1Runtime, V1RuntimeConnection, V1RuntimeConnectionCreateOptions, V1RuntimeConnectionCreateResponse, V1RuntimeCreateRequest, V1RuntimeFileCollectRequest, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeFileUploadResponse, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
-export declare class V1RuntimeConnectionResource {
-    private readonly http;
-    private readonly runtimeId;
-    readonly data: V1RuntimeConnectionCreateResponse;
-    constructor(http: V1HttpClient, runtimeId: string, data: V1RuntimeConnectionCreateResponse);
-    get id(): string;
-    get endpoint(): V1RuntimeConnectionCreateResponse['endpoint'];
-    get wsUrl(): string | undefined;
-    close(): Promise<V1RuntimeConnection>;
-}
-export declare class V1RuntimeConnectionsClient {
-    private readonly http;
-    private readonly runtimeId;
-    constructor(http: V1HttpClient, runtimeId: string);
-    create(request?: V1RuntimeConnectionCreateOptions): Promise<V1RuntimeConnectionResource>;
-    delete(connectionId: string): Promise<V1RuntimeConnection>;
-}
-export declare class V1RuntimeRunsClient {
-    private readonly http;
-    private readonly runtimeId;
-    constructor(http: V1HttpClient, runtimeId: string);
-    list(query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
-    iter(query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
-}
-export declare class V1RuntimeFilesClient {
+import { type V1HttpClient, type V1IdempotencyOptions } from './http.js';
+import { V1RuntimeInvocationsNamespaceClient } from './invocations.js';
+import type { V1ListEnvelope, V1File, V1Runtime, V1RuntimeCreateRequest, V1RuntimeFileCollectRequest, V1RuntimeFilesListQuery, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RuntimeStartResponse, V1RuntimeStopResponse, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
+export type V1RuntimeStartResult = V1RuntimeStartResponse;
+export declare class V1RuntimesClient {
     private readonly http;
-    private readonly runtimeId;
-    constructor(http: V1HttpClient, runtimeId: string);
-    upload(request: V1RuntimeFileUploadRequest): Promise<V1RuntimeFileUploadResponse>;
-    stage(request: V1RuntimeFileStageRequest): Promise<V1RuntimeStagedFile>;
-    collect(request: V1RuntimeFileCollectRequest): Promise<V1File>;
+    readonly files: V1RuntimeFilesNamespaceClient;
+    readonly runs: V1RuntimeRunsNamespaceClient;
+    readonly invocations: V1RuntimeInvocationsNamespaceClient;
+    constructor(http: V1HttpClient);
+    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1Runtime>>;
+    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1Runtime, void, undefined>;
+    create(request: V1RuntimeCreateRequest): Promise<V1Runtime>;
+    createInSpace(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1Runtime>;
+    get(id: string): Promise<V1Runtime>;
+    stop(id: string): Promise<V1RuntimeStopResponse>;
+    start(id: string, options?: V1IdempotencyOptions): Promise<V1RuntimeStartResult>;
 }
-export declare class V1RuntimeResource {
+export declare class V1RuntimeRunsNamespaceClient {
     private readonly http;
-    readonly data: V1Runtime;
-    readonly connections: V1RuntimeConnectionsClient;
-    readonly files: V1RuntimeFilesClient;
-    readonly runs: V1RuntimeRunsClient;
-    readonly invocations: V1RuntimeInvocationsClient;
-    constructor(http: V1HttpClient, data: V1Runtime);
-    get id(): string;
-    get activeRunId(): string | null;
-    refresh(): Promise<V1RuntimeResource>;
-    connect(request?: V1RuntimeConnectionCreateOptions): Promise<V1RuntimeConnectionResource>;
-    start(): Promise<{
-        runtime: V1RuntimeResource;
-        run: V1RunResource;
-    }>;
-    stop(): Promise<V1Runtime>;
-    run(): Promise<V1RunResource>;
+    constructor(http: V1HttpClient);
+    list(runtimeId: string, query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
+    iter(runtimeId: string, query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
 }
-export declare class V1RuntimesClient {
+export declare class V1RuntimeFilesNamespaceClient {
     private readonly http;
     constructor(http: V1HttpClient);
-    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1Runtime>>;
-    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1Runtime, void, undefined>;
-    create(request: V1RuntimeCreateRequest): Promise<V1RuntimeResource>;
-    createInSpace(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1RuntimeResource>;
-    get(id: string): Promise<V1RuntimeResource>;
-    stop(id: string): Promise<V1Runtime>;
-    start(id: string): Promise<{
-        runtime: V1RuntimeResource;
-        run: V1RunResource;
-    }>;
+    list(runtimeId: string, query?: V1RuntimeFilesListQuery): Promise<V1ListEnvelope<V1File>>;
+    iter(runtimeId: string, query?: V1RuntimeFilesListQuery): AsyncGenerator<V1File, void, undefined>;
+    upload(runtimeId: string, request: V1RuntimeFileUploadRequest): Promise<V1RuntimeStagedFile>;
+    stage(runtimeId: string, request: V1RuntimeFileStageRequest): Promise<V1RuntimeStagedFile>;
+    collect(runtimeId: string, request: V1RuntimeFileCollectRequest): Promise<V1File>;
 }

package/dist/runtimes.js

@@ -1,51 +1,22 @@
 import { BctrlValidationError } from './errors.js';
-import { V1RuntimeInvocationsClient } from './invocations.js';
+import { v1IdempotencyHeaders } from './http.js';
+import { V1RuntimeInvocationsNamespaceClient } from './invocations.js';
 import { iterateV1Pages } from './pagination.js';
-import { V1RunResource } from './runs.js';
-export class V1RuntimeConnectionResource {
-    http;
-    runtimeId;
-    data;
-    constructor(http, runtimeId, data) {
-        this.http = http;
-        this.runtimeId = runtimeId;
-        this.data = data;
-    }
-    get id() {
-        return this.data.id;
-    }
-    get endpoint() {
-        return this.data.endpoint;
-    }
-    get wsUrl() {
-        return this.data.endpoint.type === 'websocket' ? this.data.endpoint.url : undefined;
-    }
-    close() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(this.id)}`, { method: 'DELETE' });
-    }
-}
-export class V1RuntimeConnectionsClient {
+class V1RuntimeRunsClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
         this.http = http;
         this.runtimeId = runtimeId;
     }
-    async create(request = {}) {
-        const response = await this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections`, {
-            method: 'POST',
-            body: {
-                protocol: request.protocol ?? 'cdp',
-                ...request,
-            },
-        });
-        return new V1RuntimeConnectionResource(this.http, this.runtimeId, response);
+    list(query = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/runs`, { query });
     }
-    delete(connectionId) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(connectionId)}`, { method: 'DELETE' });
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
 }
-export class V1RuntimeRunsClient {
+class V1RuntimeFilesClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
@@ -53,19 +24,11 @@ export class V1RuntimeRunsClient {
         this.runtimeId = runtimeId;
     }
     list(query = {}) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/runs`, { query });
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files`, { query });
     }
     iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-}
-export class V1RuntimeFilesClient {
-    http;
-    runtimeId;
-    constructor(http, runtimeId) {
-        this.http = http;
-        this.runtimeId = runtimeId;
-    }
     async upload(request) {
         const form = new FormData();
         if (request.name) {
@@ -75,8 +38,10 @@ export class V1RuntimeFilesClient {
         else {
             form.set('file', request.file);
         }
-        if (request.storagePath)
-            form.set('storagePath', request.storagePath);
+        if (request.destinationPath)
+            form.set('destinationPath', request.destinationPath);
+        if (request.runtimePath)
+            form.set('runtimePath', request.runtimePath);
         if (request.metadata)
             form.set('metadata', JSON.stringify(request.metadata));
         return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/upload`, {
@@ -97,72 +62,28 @@ export class V1RuntimeFilesClient {
         });
     }
 }
-export class V1RuntimeResource {
-    http;
-    data;
-    connections;
-    files;
-    runs;
-    invocations;
-    constructor(http, data) {
-        this.http = http;
-        this.data = data;
-        this.connections = new V1RuntimeConnectionsClient(http, data.id);
-        this.files = new V1RuntimeFilesClient(http, data.id);
-        this.runs = new V1RuntimeRunsClient(http, data.id);
-        this.invocations = new V1RuntimeInvocationsClient(http, data.id);
-    }
-    get id() {
-        return this.data.id;
-    }
-    get activeRunId() {
-        return this.data.activeRunId;
-    }
-    refresh() {
-        return new V1RuntimesClient(this.http).get(this.id);
-    }
-    async connect(request) {
-        return this.connections.create(request);
-    }
-    async start() {
-        const response = await this.http.request(`/runtimes/${encodeURIComponent(this.id)}/start`, { method: 'POST' });
-        return {
-            runtime: new V1RuntimeResource(this.http, response.runtime),
-            run: new V1RunResource(this.http, response.run),
-        };
-    }
-    stop() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.id)}/stop`, {
-            method: 'POST',
-        });
-    }
-    async run() {
-        const runtime = await this.refresh();
-        if (!runtime.activeRunId) {
-            throw new BctrlValidationError('Runtime does not have an active run yet', 'runtime.no_active_run', {
-                runtimeId: this.id,
-            });
-        }
-        const run = await this.http.request(`/runs/${encodeURIComponent(runtime.activeRunId)}`);
-        return new V1RunResource(this.http, run);
-    }
-}
 function validateRuntimeCreateRequest(request) {
-    const profileBacked = request.config?.browser?.profile === true;
+    const profileBacked = request.config?.profile === true;
     if (!profileBacked)
         return;
     if (!request.name?.trim()) {
-        throw new BctrlValidationError('name is required when config.browser.profile is true', 'runtime.profile_name_required');
+        throw new BctrlValidationError('name is required when config.profile is true', 'runtime.profile_name_required');
     }
-    const unsupported = ['stealth', 'proxy', 'fingerprint', 'extensions'].filter((key) => request.config?.[key] !== undefined);
+    const unsupported = ['stealth', 'proxy', 'fingerprint', 'extensionIds'].filter((key) => request.config?.[key] !== undefined);
     if (unsupported.length > 0) {
-        throw new BctrlValidationError('Only config.browser.profile and config.lifecycle are supported for profile-backed browser runtimes', 'runtime.profile_config_unsupported', { unsupported });
+        throw new BctrlValidationError('Only config.profile, config.idleTimeoutMinutes, config.webRtcProxyOnly, config.forceOpenShadowRoots, and config.networkTraffic are supported for profile-backed browser runtimes', 'runtime.profile_config_unsupported', { unsupported });
     }
 }
 export class V1RuntimesClient {
     http;
+    files;
+    runs;
+    invocations;
     constructor(http) {
         this.http = http;
+        this.files = new V1RuntimeFilesNamespaceClient(http);
+        this.runs = new V1RuntimeRunsNamespaceClient(http);
+        this.invocations = new V1RuntimeInvocationsNamespaceClient(http);
     }
     list(query = {}) {
         return this.http.request('/runtimes', { query });
@@ -172,31 +93,63 @@ export class V1RuntimesClient {
     }
     async create(request) {
         validateRuntimeCreateRequest(request);
-        const runtime = await this.http.request('/runtimes', {
+        return this.http.request('/runtimes', {
             method: 'POST',
             body: request,
         });
-        return new V1RuntimeResource(this.http, runtime);
     }
     async createInSpace(spaceId, request) {
         validateRuntimeCreateRequest(request);
-        const runtime = await this.http.request('/runtimes', {
+        return this.http.request('/runtimes', {
             method: 'POST',
             body: { ...request, spaceId },
         });
-        return new V1RuntimeResource(this.http, runtime);
     }
-    async get(id) {
-        const runtime = await this.http.request(`/runtimes/${encodeURIComponent(id)}`);
-        return new V1RuntimeResource(this.http, runtime);
+    get(id) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}`);
     }
     stop(id) {
         return this.http.request(`/runtimes/${encodeURIComponent(id)}/stop`, {
             method: 'POST',
         });
     }
-    async start(id) {
-        const runtime = await this.get(id);
-        return runtime.start();
+    async start(id, options) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}/start`, {
+            method: 'POST',
+            headers: v1IdempotencyHeaders(options),
+        });
+    }
+}
+export class V1RuntimeRunsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runtimeId, query = {}) {
+        return new V1RuntimeRunsClient(this.http, runtimeId).list(query);
+    }
+    iter(runtimeId, query = {}) {
+        return new V1RuntimeRunsClient(this.http, runtimeId).iter(query);
+    }
+}
+export class V1RuntimeFilesNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runtimeId, query = {}) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).list(query);
+    }
+    iter(runtimeId, query = {}) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).iter(query);
+    }
+    upload(runtimeId, request) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).upload(request);
+    }
+    stage(runtimeId, request) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).stage(request);
+    }
+    collect(runtimeId, request) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).collect(request);
     }
 }

package/dist/schemas.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import type { JsonObject } from './types.js';
+export type JsonSchemaObject = JsonObject;
+export type JsonSchemaLike = JsonSchemaObject | {
+    toJSONSchema: () => unknown;
+} | z.ZodType;
+export declare function toOutputSchema(schema: JsonSchemaLike, label?: string): JsonSchemaObject;

package/dist/schemas.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export function toOutputSchema(schema, label = 'schema') {
+    const value = resolveSchema(schema);
+    if (!isJsonObject(value)) {
+        throw new TypeError(`${label} must resolve to a JSON Schema object`);
+    }
+    const { $schema, ...jsonSchema } = value;
+    void $schema;
+    return jsonSchema;
+}
+function resolveSchema(schema) {
+    if (hasToJSONSchema(schema)) {
+        return schema.toJSONSchema();
+    }
+    const zodJsonSchema = tryZodToJsonSchema(schema);
+    if (zodJsonSchema !== undefined)
+        return zodJsonSchema;
+    return schema;
+}
+function hasToJSONSchema(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        'toJSONSchema' in value &&
+        typeof value.toJSONSchema === 'function');
+}
+function tryZodToJsonSchema(value) {
+    try {
+        return z.toJSONSchema(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isJsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/spaces.d.ts

@@ -1,40 +1,28 @@
 import type { V1HttpClient } from './http.js';
-import { V1RuntimeResource, V1RuntimesClient } from './runtimes.js';
-import type { V1ListEnvelope, V1RuntimeListQuery, V1Space, V1SpaceCreateRequest, V1SpaceEnvironment, V1SpaceEnvironmentUpdateRequest, V1SpaceRuntimeCreateRequest, V1SpaceUpdateRequest } from './types.js';
-export declare class V1SpaceEnvironmentClient {
-    private readonly http;
-    private readonly spaceId;
-    constructor(http: V1HttpClient, spaceId: string);
-    get(): Promise<V1SpaceEnvironment>;
-    update(request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
-}
-export declare class V1SpaceRuntimesClient {
+import { V1RuntimesClient } from './runtimes.js';
+import type { V1ListEnvelope, V1Runtime, V1RuntimeListQuery, V1Space, V1SpaceCreateRequest, V1SpaceDeleteResponse, V1SpaceEnvironment, V1SpaceEnvironmentUpdateRequest, V1SpaceListQuery, V1SpaceRuntimeCreateRequest, V1SpaceUpdateRequest } from './types.js';
+export declare class V1SpacesClient {
     private readonly http;
-    private readonly spaceId;
-    constructor(http: V1HttpClient, spaceId: string);
-    list(query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['list']>;
-    iter(query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['iter']>;
-    create(request: V1SpaceRuntimeCreateRequest): Promise<V1RuntimeResource>;
-    get(runtimeId: string): Promise<V1RuntimeResource>;
-    stop(runtimeId: string): ReturnType<V1RuntimesClient['stop']>;
-    start(runtimeId: string): ReturnType<V1RuntimesClient['start']>;
+    readonly environment: V1SpaceEnvironmentNamespaceClient;
+    readonly runtimes: V1SpaceRuntimesNamespaceClient;
+    constructor(http: V1HttpClient);
+    list(query?: V1SpaceListQuery): Promise<V1ListEnvelope<V1Space>>;
+    iter(query?: V1SpaceListQuery): AsyncGenerator<V1Space, void, undefined>;
+    create(request: V1SpaceCreateRequest): Promise<V1Space>;
+    get(id: string): Promise<V1Space>;
+    update(id: string, request: V1SpaceUpdateRequest): Promise<V1Space>;
+    delete(id: string): Promise<V1SpaceDeleteResponse>;
 }
-export declare class V1SpaceResource {
+export declare class V1SpaceEnvironmentNamespaceClient {
     private readonly http;
-    readonly data: V1Space;
-    readonly environment: V1SpaceEnvironmentClient;
-    readonly runtimes: V1SpaceRuntimesClient;
-    constructor(http: V1HttpClient, data: V1Space);
-    get id(): string;
-    refresh(): Promise<V1SpaceResource>;
-    update(request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
+    constructor(http: V1HttpClient);
+    get(spaceId: string): Promise<V1SpaceEnvironment>;
+    update(spaceId: string, request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
 }
-export declare class V1SpacesClient {
+export declare class V1SpaceRuntimesNamespaceClient {
     private readonly http;
     constructor(http: V1HttpClient);
-    list(): Promise<V1ListEnvelope<V1Space>>;
-    iter(): AsyncGenerator<V1Space, void, undefined>;
-    create(request: V1SpaceCreateRequest): Promise<V1SpaceResource>;
-    get(id: string): Promise<V1SpaceResource>;
-    update(id: string, request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
+    list(spaceId: string, query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['list']>;
+    iter(spaceId: string, query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['iter']>;
+    create(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1Runtime>;
 }