@idapt/browser-app-sdk 0.1.0

package/dist/client-h2Wsvn7a.d.ts

@@ -0,0 +1,2213 @@
+import { H as HttpContext, C as CallOptions, F as File$1, g as Agent, b as DeletedResponse, j as ApiKey, ac as Permission, aF as SpeechResult, aQ as TranscriptionResult, aG as SpeechStreamEvent, aR as TranscriptionStreamEvent, B as BlobObject, q as Chat, r as ChatCost, a4 as MessageCosts, t as ChatStopResult, a2 as Message, aw as SendMessageResult, i as AgentRunState, h as AgentRun, aq as RepromptResult, R as ExecutionRun, Q as ExecutionBackend, S as ExecutionRunStatus, v as Computer, E as ComputerServerInfo, x as ComputerExecResult, aP as TmuxWindow, ay as SftpEntry, z as ComputerPort, J as ComputerUser, a0 as ListEnvelope, w as ComputerEnvVar, O as DatastoreEntry, d as FileUploadResult, W as WriteOptions, X as ImageModel, V as ImageGenerationResult, Z as LLMModel, a7 as Notification, a8 as NotificationConfig, a9 as NotificationPreference, af as ProviderEndpointKind, aj as ProviderEndpointProviderKey, ae as ProviderEndpointConnectionType, am as ProviderEndpointTransport, ak as ProviderEndpointRuntime, ai as ProviderEndpointProtocol, an as ProviderEndpointVisibility, ag as ProviderEndpointModality, ad as ProviderEndpoint, a1 as ManagedProviderPreset, al as ProviderEndpointTestResult, at as SearchResult, au as Secret, av as SecretWithValue, ax as Settings, aC as ShareResourceType, aB as SharePermission, az as Share, aA as ShareDeletedResult, aD as SharedWithMeItem, aJ as StoreItemType, aI as StoreItem, aH as StoreInstallResult, aL as Subscription, aN as TableCollection, aO as TableRecord, aS as Trigger, K as CreateTriggerInput, aX as TriggerWithSecret, a_ as UpdateTriggerInput, aV as TriggerRun, aU as TriggerCostStats, b1 as User, b0 as UsageSummary, a$ as UsageRecord, b3 as WebSearchResponse, b7 as WorkspaceMemberRole, b4 as Workspace, b6 as WorkspaceMember, b5 as WorkspaceInvitation, k as AppFolder, M as DataFolder, u as ClientMeta, as as RuntimeMode, aK as StoredCredential, P as EscalateRequest } from './data-Chus9wn2.js';
+
+/**
+ * Stateless low-level file operations against `/api/v1/drive/files/*`.
+ *
+ * Every file surface in the SDK (FilesApi, DataFolder, AppFolder) ultimately
+ * hits the same v1 endpoints. Keeping the HTTP details here means:
+ *
+ *   - one place to fix envelope / OCC / multipart behaviour
+ *   - scoped surfaces (DataFolder, AppFolder) compose instead of duplicate
+ *   - new scoped methods (e.g. subfolder create under `.app-data/`) cost one
+ *     delegating line instead of a re-implemented request() call
+ *
+ * Nothing in this module caches or holds state — callers layer that on.
+ */
+
+/**
+ * `GET /v1/files` query params. Cursor-paginated (`limit` + opaque
+ * `cursor`). There is NO `workspace_id` filter — list within a workspace by
+ * passing the workspace's root folder as `parent_id`.
+ *
+ * To page: pass no `cursor` for the first page, then echo back the
+ * `pagination.next_cursor` from the previous response (use `listEnvelope`
+ * if you need that token — `list` drops the envelope).
+ */
+interface ListFilesQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+    parent_id?: string;
+}
+interface UploadInput {
+    file: Blob | globalThis.File;
+    name?: string;
+    parent_id?: string;
+    workspace_id?: string;
+    skip_if_exists?: boolean;
+}
+interface PatchFileInput {
+    name?: string;
+    content?: string;
+    expected_updated_at?: string;
+}
+interface CreateFolderInput {
+    name: string;
+    parent_id?: string;
+    workspace_id?: string;
+    icon?: string;
+}
+interface RunFileInput {
+    timeout_seconds?: number;
+    env?: Record<string, string>;
+}
+declare function listFiles(ctx: HttpContext, query?: ListFilesQuery, opts?: CallOptions): Promise<File$1[]>;
+/** GET raw text body (`expectJson: false`). UTF-8 decoded by `fetch`. */
+declare function getFileText(ctx: HttpContext, id: string, opts?: CallOptions): Promise<string>;
+/** GET raw bytes as Blob, preserving Content-Type. */
+declare function getFileBlob(ctx: HttpContext, id: string, opts?: CallOptions): Promise<Blob>;
+
+/**
+ * AgentsApi — `/api/v1/agents` CRUD.
+ *
+ * Agents are standalone resources scoped to a workspace (personal or
+ * user-created). See `lib/browser-app/authorize.ts` for the permission model.
+ */
+
+/**
+ * `GET /v1/agents` query params. Cursor-paginated (`limit` + opaque
+ * `cursor`); `workspace_id` narrows the listing to one workspace.
+ */
+interface ListAgentsQuery {
+    workspace_id?: string;
+    scope?: "all";
+    type?: "user" | "generated";
+    include_archived?: boolean;
+    archived_only?: boolean;
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+}
+interface CreateAgentInput {
+    name: string;
+    icon: string;
+    description?: string;
+    system_prompt?: string;
+    workspace_id?: string;
+    authorization?: Record<string, unknown> | null;
+    compaction_preset?: "minimal" | "normal" | "detailed" | null;
+    compaction_summary_percent?: number | null;
+    compaction_summary_max_tokens?: number | null;
+    compaction_preserved_percent?: number | null;
+    compaction_preserved_max_tokens?: number | null;
+    compaction_msg_percent?: number | null;
+    compaction_msg_max_tokens?: number | null;
+    type?: "user" | "generated";
+    memory_folder?: string | null;
+    default_model_id?: string;
+    default_reasoning_effort?: number | null;
+    default_auto_cost_level?: number | null;
+    default_cost_budget_limit_usd?: number | null;
+}
+interface UpdateAgentInput {
+    name?: string;
+    icon?: string;
+    description?: string | null;
+    system_prompt?: string | null;
+    authorization?: Record<string, unknown> | null;
+    compaction_preset?: "minimal" | "normal" | "detailed" | null;
+    compaction_summary_percent?: number | null;
+    compaction_summary_max_tokens?: number | null;
+    compaction_preserved_percent?: number | null;
+    compaction_preserved_max_tokens?: number | null;
+    compaction_msg_percent?: number | null;
+    compaction_msg_max_tokens?: number | null;
+    type?: "user" | "generated";
+    memory_folder?: string | null;
+    default_model_id?: string | null;
+    default_reasoning_effort?: number | null;
+    default_auto_cost_level?: number | null;
+    default_cost_budget_limit_usd?: number | null;
+}
+interface MoveAgentInput {
+    workspace_id: string;
+}
+interface CopyAgentToWorkspaceInput {
+    workspace_id: string;
+}
+declare class AgentsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query?: ListAgentsQuery, opts?: CallOptions): Promise<Agent[]>;
+    create(input: CreateAgentInput, opts?: CallOptions): Promise<Agent>;
+    get(id: string, opts?: CallOptions): Promise<Agent>;
+    update(id: string, input: UpdateAgentInput, opts?: CallOptions): Promise<Agent>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    archive(id: string, opts?: CallOptions): Promise<Agent>;
+    unarchive(id: string, opts?: CallOptions): Promise<Agent>;
+    restore(id: string, opts?: CallOptions): Promise<Agent>;
+    permanentDelete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    move(id: string, input: MoveAgentInput, opts?: CallOptions): Promise<Agent>;
+    copyToWorkspace(id: string, input: CopyAgentToWorkspaceInput, opts?: CallOptions): Promise<Agent>;
+}
+
+/**
+ * ApiKeysApi — `/api/v1/api-keys`.
+ *
+ * Each user can mint long-lived `uk_` keys to authenticate scripts, CLIs,
+ * and external integrations against the v1 API. Keys are scoped by the
+ * `Permission[]` passed at creation time (omit for full-access).
+ *
+ * Constraints inherited from the route:
+ *   - Paid tier only (free tier has `MAX_API_KEYS = 0`).
+ *   - Per-tier cap on total keys + per-tier max expiration window.
+ *   - Header-auth (using an API key) cannot list, create, modify, or revoke
+ *     other API keys — only the first-party session-cookie path is allowed. This SDK
+ *     mirrors the rule: when you talk to it with a `uk_` key, these calls
+ *     will 403.
+ *   - Plaintext key value is returned ONCE on `create` and never again —
+ *     the server only persists the hash.
+ */
+
+interface ListApiKeysQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+}
+interface CreateApiKeyInput {
+    name: string;
+    /**
+     * Permission set. Omit / null → full access (capability of caller).
+     * For "all scopes, read-only" use `[{ resource: "*", access: "read" }]`.
+     */
+    permissions?: Permission[] | null;
+    /**
+     * Seconds from now until expiration. `0` is non-expiring (Max tier only).
+     * Omit to use the tier-default maximum.
+     */
+    expires_in?: number;
+}
+interface UpdateApiKeyInput {
+    permissions?: Permission[] | null;
+    enabled?: boolean;
+}
+interface RotateApiKeyInput {
+    /** 1 hour, 24 hours, or 7 days. */
+    grace_period_seconds: 3600 | 86400 | 604800;
+}
+interface RotateApiKeyResult extends ApiKey {
+    /** Plaintext replacement key — present only on the rotate response. */
+    key: string;
+    /** Preview/fingerprint of the old key being rotated out. */
+    old_key_preview?: string | null;
+    /** ISO timestamp when the old key stops authenticating. */
+    grace_period_expires_at: string;
+}
+declare class ApiKeysApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query?: ListApiKeysQuery, opts?: CallOptions): Promise<ApiKey[]>;
+    /**
+     * Mint a new API key. The returned object includes a one-shot `key` field
+     * with the plaintext — store it immediately, there is no way to retrieve
+     * it later.
+     */
+    create(input: CreateApiKeyInput, opts?: CallOptions): Promise<ApiKey>;
+    update(id: string, input: UpdateApiKeyInput, opts?: CallOptions): Promise<ApiKey>;
+    /** Revoke (delete) a key. Subsequent calls with that key 401. */
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /**
+     * Rotate a key and return the replacement plaintext once. API-key
+     * management remains first-party session-only on the server, so calls made
+     * with a raw `uk_` bearer key receive 403.
+     */
+    rotate(id: string, input: RotateApiKeyInput, opts?: CallOptions): Promise<RotateApiKeyResult>;
+}
+
+/**
+ * AudioApi — `/api/v1/audio/*`.
+ *
+ * Two endpoints:
+ *   - `POST /audio/speech`         → text-to-speech, writes a file ref.
+ *                                    Responds HTTP 201 (resource created).
+ *   - `POST /audio/transcriptions` → multipart upload, returns `{ text }`
+ *
+ * Transcription accepts any Blob/File you already have in memory (e.g.,
+ * from a MediaRecorder session). Speech writes into the caller's workspace.
+ */
+
+interface SpeakInput {
+    text: string;
+    workspace_id: string;
+    model?: string;
+    voice?: string;
+    speed?: number;
+    pitch?: number;
+    emotion?: string;
+    output_path?: string;
+}
+interface TranscribeInput {
+    file: Blob | File;
+    model?: string;
+    language?: string;
+    /** Override the filename attached to the multipart upload. */
+    filename?: string;
+}
+interface SpeakStreamInput {
+    text: string;
+    model?: string;
+    voice?: string;
+    speed?: number;
+}
+declare class AudioApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /** Text-to-speech. Responds HTTP 201 with the written file ref under `data`. */
+    speak(input: SpeakInput, opts?: CallOptions): Promise<SpeechResult>;
+    transcribe(input: TranscribeInput, opts?: CallOptions): Promise<TranscriptionResult>;
+    streamSpeech(input: SpeakStreamInput, opts?: CallOptions): AsyncIterable<SpeechStreamEvent>;
+    streamTranscribe(input: TranscribeInput, opts?: CallOptions): AsyncIterable<TranscriptionStreamEvent>;
+}
+
+/**
+ * BlobsApi — `/api/v1/blobs` (the object-storage data plane).
+ *
+ * Workspace-scoped object store. Objects live under a `namespace` (a bucket you
+ * pick) and a `key`. The companion to `client.kv` (Datastore) — KV holds small
+ * inline JSON, Blobs holds large / binary data. Surfaced as `client.blobs.*` on
+ * `IdaptClient`.
+ */
+
+interface BlobsListOptions extends CallOptions {
+    /** Only keys starting with this prefix. */
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+}
+/** Per-object metadata returned by `list`. */
+interface BlobMeta {
+    key: string;
+    content_type: string;
+    size: number;
+    updated_at: string;
+}
+declare class BlobsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /** List objects in a namespace (prefix-filterable). */
+    list(namespace: string, opts?: BlobsListOptions): Promise<BlobMeta[]>;
+    /**
+     * Upload (upsert) an object's bytes. Returns its metadata.
+     *
+     * Sent as `multipart/form-data` (the bytes ride a `file` part, with an
+     * optional `content_type` field) — the same upload convention as
+     * `client.files.upload`, so it flows through the one multipart transport and
+     * is reachable identically via `client.call("blobs put", …)`. The SDK leaves
+     * `Content-Type` unset so the runtime picks the multipart boundary.
+     */
+    put(namespace: string, key: string, content: Blob | ArrayBuffer | Uint8Array, contentType?: string, opts?: CallOptions): Promise<BlobObject>;
+    /**
+     * Download an object's raw bytes (preserving its stored Content-Type).
+     *
+     * `GET /blobs/:ns/:key` returns JSON metadata + a signed URL by default (the
+     * agent/CLI form); `?download=true` is the raw-bytes escape hatch this facade
+     * uses. For the JSON reference instead, call `client.call("blobs get", …)`.
+     */
+    get(namespace: string, key: string, opts?: CallOptions): Promise<{
+        blob: Blob;
+        contentType: string;
+    }>;
+    /** Read an object's metadata (no bytes). */
+    head(namespace: string, key: string, opts?: CallOptions): Promise<BlobObject>;
+    /** Delete an object (idempotent). */
+    delete(namespace: string, key: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /** Mint a time-limited direct-download URL for an object. */
+    createSignedUrl(namespace: string, key: string, expiresIn?: number, opts?: CallOptions): Promise<{
+        url: string;
+        expires_at: string;
+    }>;
+    /** List the blob namespaces in the workspace. */
+    listNamespaces(opts?: CallOptions): Promise<string[]>;
+}
+
+/**
+ * GENERATED FILE — DO NOT EDIT BY HAND.
+ *
+ * Runtime command-bindings table for the SDK's generic `call(action, args)`
+ * executor — one entry per v1 command (HTTP binding only: method, path,
+ * pathParams, argLocation, responseKind, async, binary content types).
+ *
+ * Generated from the zod contract registry
+ * (`packages/api-contracts/src/v1/contracts`) by
+ * `scripts/generate-sdk.ts`. PURE literal data — NO zod, NO
+ * `@idapt/api-contracts` import — so the published SDK ships zero runtime
+ * `@idapt/*` dependencies.
+ *
+ * Regenerate:  npx tsx scripts/generate-sdk.ts
+ * Drift check: npx tsx scripts/check-sdk-drift.ts   (CI + pre-commit)
+ */
+/** HTTP binding for a single v1 command, addressed by its `<resource> <verb>` string. */
+interface CommandBinding {
+    /** The canonical `<resource> <verb>` command string (also the map key). */
+    command: string;
+    method: "GET" | "POST" | "PATCH" | "DELETE";
+    /** Path relative to `/api/v1`, with `:param` placeholders, e.g. `/drive/files/:id`. */
+    path: string;
+    /** Request fields that fill the `:param` placeholders, in path order. */
+    pathParams: readonly string[];
+    /** Where the remaining (non-path) request fields are carried. */
+    argLocation: "path" | "query" | "body" | "multipart";
+    /** Shape of the response payload. */
+    responseKind: "single" | "list" | "created" | "deleted" | "binary";
+    /** Long-running → goes through the async-operation layer. */
+    async: boolean;
+    /** For `binary` responses — the served media types (e.g. `text/event-stream`). */
+    binaryContentTypes?: readonly string[];
+}
+declare const COMMAND_BINDINGS: Record<string, CommandBinding>;
+/**
+ * Literal union of every known v1 command string (the keys of
+ * {@link COMMAND_BINDINGS}). Used to type `client.call(action, args)` so a
+ * known action autocompletes and a typo is caught at compile time.
+ */
+type V1CommandName = "agent archive" | "agent copy-to-workspace" | "agent create" | "agent delete" | "agent get" | "agent list" | "agent move" | "agent permanent-delete" | "agent restore" | "agent unarchive" | "agent update" | "ai-gateway providers" | "ai-gateway usage" | "api-key create" | "api-key delete" | "api-key list" | "api-key rotate" | "api-key update" | "audio models" | "audio search-models" | "audio search-voices" | "audio speak" | "audio speak-stream" | "audio transcribe" | "audio transcribe-stream" | "audio voices" | "blobs delete" | "blobs get" | "blobs head" | "blobs list" | "blobs namespaces" | "blobs put" | "blobs signed-url" | "browser-app create" | "browser-app deploy" | "browser-app deployments" | "browser-app fork" | "browser-app get" | "browser-app list" | "browser-app promote" | "browser-app snapshot" | "chat archive" | "chat copy-to-agent" | "chat copy-to-workspace" | "chat cost" | "chat create" | "chat delete" | "chat export" | "chat fork-to-workspace" | "chat get" | "chat list" | "chat message-costs" | "chat messages" | "chat permanent-delete" | "chat reprompt" | "chat restore" | "chat runs" | "chat send" | "chat stop" | "chat stream" | "chat unarchive" | "chat update" | "ci cancel" | "ci get" | "ci jobs" | "ci list" | "ci run" | "code execute" | "code get" | "code interrupt" | "code list" | "computer activity" | "computer add-local-model" | "computer app-create" | "computer app-delete" | "computer app-exec" | "computer app-expose" | "computer app-external" | "computer app-get" | "computer app-logs" | "computer app-ports" | "computer app-reset" | "computer app-restart" | "computer app-run" | "computer app-runtime" | "computer app-setup-runtime" | "computer app-start" | "computer app-stop" | "computer app-unexpose" | "computer apps" | "computer archive" | "computer compose-up" | "computer create" | "computer create-user" | "computer delete" | "computer delete-user" | "computer delete-user-env" | "computer download" | "computer exec" | "computer expose" | "computer get" | "computer get-user" | "computer hibernate" | "computer link" | "computer links" | "computer list" | "computer local-inference" | "computer local-models" | "computer manage" | "computer pair" | "computer ports" | "computer remove-local-model" | "computer set-ports" | "computer set-user-env" | "computer sftp" | "computer start" | "computer stop" | "computer test-connection" | "computer tmux" | "computer tunnels" | "computer unarchive" | "computer unexpose" | "computer unlink" | "computer update" | "computer update-user" | "computer upload" | "computer user-env" | "computer user-env-setup" | "computer user-env-setup-apply" | "computer user-env-sync" | "computer user-env-sync-repair" | "computer users" | "datastore batch" | "datastore delete" | "datastore get" | "datastore increment" | "datastore list" | "datastore namespaces" | "datastore set" | "drive content-versions" | "drive create-folder" | "drive delete" | "drive get-metadata" | "drive glob" | "drive grep" | "drive list" | "drive move" | "drive permanent-delete" | "drive read" | "drive restore" | "drive restore-version" | "drive run" | "drive update" | "drive upload" | "guide get" | "hook create" | "hook delete" | "hook get" | "hook history" | "hook list" | "hook override" | "hook preview" | "hook toggle" | "hook update" | "hub install" | "hub search" | "hub submissions" | "hub submit" | "hub update" | "hub update-check" | "image generate" | "image models" | "image search" | "me get" | "me usage" | "models list" | "models search" | "notes box-create" | "notes box-delete" | "notes box-get" | "notes box-list" | "notes box-update" | "notes delete" | "notes graph" | "notes index-read" | "notes index-write" | "notes links" | "notes list" | "notes note-rename" | "notes read" | "notes search" | "notes search-all" | "notes tag-list" | "notes tag-rename" | "notes write" | "notification config" | "notification delete" | "notification get" | "notification list" | "notification preferences" | "notification read-all" | "notification send" | "notification update" | "notification update-config" | "notification update-preferences" | "operation cancel" | "operation get" | "operation list" | "provider-endpoint create" | "provider-endpoint delete" | "provider-endpoint list" | "provider-endpoint presets" | "provider-endpoint test" | "provider-endpoint update" | "realtime broadcast" | "realtime presence" | "realtime presence-list" | "realtime subscribe" | "repos branches" | "repos clone-url" | "repos commit" | "repos commits" | "repos create" | "repos delete" | "repos get" | "repos list" | "repos read-file" | "repos set-visibility" | "search query" | "secret create" | "secret delete" | "secret get" | "secret list" | "secret reveal" | "secret update" | "settings get" | "settings update" | "share create" | "share delete" | "share list" | "share update" | "shared-with-me list" | "skill apply-update" | "skill attach" | "skill body" | "skill create" | "skill delete" | "skill detach" | "skill file-delete" | "skill file-list" | "skill file-read" | "skill file-write" | "skill fork" | "skill get" | "skill install" | "skill list" | "skill publish" | "skill render" | "skill search" | "skill update" | "skill update-check" | "subscription get" | "table create" | "table create-record" | "table delete" | "table delete-record" | "table export" | "table get" | "table get-record" | "table import" | "table list" | "table query" | "table update" | "table update-record" | "tasks ancestors" | "tasks assign" | "tasks comment" | "tasks comment-delete" | "tasks comment-list" | "tasks comment-update" | "tasks create" | "tasks delete" | "tasks depend" | "tasks dependencies" | "tasks duplicate" | "tasks events" | "tasks get" | "tasks label-create" | "tasks label-delete" | "tasks label-list" | "tasks label-update" | "tasks list" | "tasks list-create" | "tasks list-delete" | "tasks list-get" | "tasks list-list" | "tasks list-update" | "tasks unassign" | "tasks undepend" | "tasks update" | "trigger archive" | "trigger cost-stats" | "trigger cost-stats-all" | "trigger create" | "trigger delete" | "trigger fire" | "trigger get" | "trigger list" | "trigger rotate-secret" | "trigger runs" | "trigger test-fire" | "trigger unarchive" | "trigger update" | "web fetch" | "web search" | "workspace add-member" | "workspace archive" | "workspace create" | "workspace delete" | "workspace get" | "workspace invitations" | "workspace invite" | "workspace list" | "workspace members" | "workspace remove-member" | "workspace revoke-invitation" | "workspace unarchive" | "workspace update" | "workspace update-member";
+
+/**
+ * Generic, spec-driven command executor — the SDK twin of the CLI's `runSpec`.
+ *
+ * `executeCommand` takes one {@link CommandBinding} (from the generated
+ * `COMMAND_BINDINGS` table) plus a flat `args` bag and turns it into a fully
+ * assembled v1 HTTP call: it binds the `:param` placeholders from `args`,
+ * routes the remaining fields by `argLocation` (query / JSON body / multipart),
+ * sends through the SDK's single {@link request}/{@link requestRaw} transport,
+ * and unwraps the response envelope by `responseKind`. For `async` verbs it can
+ * poll the operation handle to completion ({@link awaitOperation}).
+ *
+ * This is what powers `client.call(action, args)`: because the binding table is
+ * generated from the same contract registry the routes are, EVERY v1 command is
+ * reachable through this one path — no per-verb code, 100% parity by
+ * construction. It deliberately mirrors `packages/cli/src/execute.ts` so the
+ * CLI and SDK agree on path-binding, request assembly, envelope unwrap, and
+ * operation polling.
+ */
+
+/** Options for {@link executeCommand}. */
+interface ExecuteCommandOptions {
+    /**
+     * For `async` verbs: poll the operation handle to a terminal status before
+     * resolving (default). Pass `wait: false` to resolve with the raw operation
+     * handle (`{ id, status, … }`) immediately — the caller then polls
+     * `operation get` itself. Ignored for non-async verbs.
+     */
+    wait?: boolean;
+    signal?: AbortSignal;
+    /** Poll cadence for async operations (default 1500ms). */
+    pollIntervalMs?: number;
+    /** Max poll attempts before giving up and throwing (default 120). */
+    maxPollAttempts?: number;
+    /** Injectable delay (tests pass a no-op); defaults to real `setTimeout`. */
+    sleep?: (ms: number) => Promise<void>;
+    /**
+     * For `binary` SSE bindings (`text/event-stream`): when true, buffer the whole
+     * stream and return it as a `Blob` instead of an `AsyncIterable<SseEvent>`.
+     * Non-streaming callers — the `idapt` CLI and the in-chat dispatcher, which
+     * render a single buffered tool result — set this; the default (false) streams
+     * frames for live consumers. Non-SSE binaries return a `Blob` either way.
+     */
+    bufferBinary?: boolean;
+}
+/** One parsed Server-Sent Events frame. */
+interface SseEvent {
+    event: string;
+    data: string;
+}
+/** List envelope shape returned for `responseKind: "list"`. */
+interface ListResult<T = unknown> {
+    data: T[];
+    pagination: {
+        has_more: boolean;
+        next_cursor: string | null;
+    };
+}
+/** Deleted envelope shape returned for `responseKind: "deleted"`. */
+interface DeletedResult {
+    deleted: boolean;
+    id: string;
+}
+/**
+ * Execute one v1 command from its {@link CommandBinding} + flat `args`.
+ *
+ * Return shape by `responseKind`:
+ *  - `single` / `created` → the unwrapped resource (`.data`)
+ *  - `list`               → `{ data, pagination }` ({@link ListResult})
+ *  - `deleted`            → `{ deleted, id }` ({@link DeletedResult})
+ *  - `binary` (SSE)       → an `AsyncIterable<SseEvent>` of raw frames
+ *  - `binary` (other)     → a `Blob`
+ *
+ * For `async` verbs the initial response is an operation handle; unless
+ * `opts.wait === false`, this polls `GET /api/v1/operations/:id` to a terminal
+ * status and resolves with the operation's `result` (or throws on
+ * failed/cancelled). The generic `T` is the caller's expected payload type.
+ */
+declare function executeCommand<T = unknown>(binding: CommandBinding, args: Record<string, unknown> | undefined, ctx: HttpContext, opts?: ExecuteCommandOptions): Promise<T>;
+/**
+ * Poll `GET /api/v1/operations/:id` until the operation reaches a terminal
+ * status, then resolve with its `result` (on `completed`) or throw an
+ * {@link IdaptError} (on `failed` / `cancelled`). Built via the same request
+ * machinery as every other call. The operations route may not exist yet — this
+ * only runs for `async` verbs when `wait` is on.
+ */
+declare function awaitOperation<T = unknown>(binding: CommandBinding, operationId: string, ctx: HttpContext, opts?: ExecuteCommandOptions): Promise<T>;
+
+/**
+ * ChatsApi — `/api/v1/chats` CRUD + sub-resources.
+ *
+ * Sub-resources are exposed as flat methods keyed by chat id so consumers
+ * don't need an extra factory step: `chats.listMessages(chatId)` instead of
+ * `chats.messages(chatId).list()`.
+ *
+ * `sendMessage` wraps the "post user message, wait for assistant reply"
+ * flow. With `wait: true` (default) the server holds the connection until
+ * the reply is ready (up to `timeout` seconds); with `wait: false` the
+ * server responds `202`-style with a pending reference.
+ */
+
+interface ListChatsQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+    agent_id?: string;
+    workspace_id?: string;
+}
+interface CreateChatInput {
+    title?: string;
+    agent_id?: string;
+    workspace_id?: string;
+    default_model?: string;
+}
+interface UpdateChatInput {
+    title?: string;
+    icon?: string | null;
+    default_model?: string | null;
+}
+interface ListMessagesQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+}
+interface SendMessageInput {
+    content: string;
+    model_id?: string;
+    /** Default `true`. Set false to get a pending reference. */
+    wait?: boolean;
+    /** Seconds the server is allowed to block. Default `120`. Max `300`. */
+    timeout?: number;
+    /**
+     * Optional idempotency tag — repeat POSTs with the same key (within the
+     * server's dedupe window) return the original result instead of sending
+     * the message twice. Safe to set on retried requests.
+     */
+    idempotency_key?: string;
+}
+interface StreamMessageInput {
+    content: string;
+    model_id?: string;
+    /** 0–100 reasoning effort for reasoning-capable models. */
+    reasoning_level?: number;
+    effort_level?: "fast" | "smart" | "expert";
+    /** 0–100 cost tier, only meaningful when the chat model is `"auto"`. */
+    cost_level?: number;
+    /** Branch the conversation from this message id instead of the active leaf. */
+    branch_from?: string;
+    /** Optional idempotency tag — repeated streams with the same key dedupe. */
+    idempotency_key?: string;
+    /** Max seconds to stream before a terminal `done: timeout`. Default `120`. */
+    timeout?: number;
+}
+interface RepromptMessageInput {
+    /** Override the chat's default model. `"auto"` routes via auto-router. */
+    model_id?: string;
+    effort_level?: "fast" | "smart" | "expert";
+    /** 0–100, power-user override for explicit reasoning effort. */
+    reasoning_level?: number;
+    /** 0–100, only meaningful when `model_id` is `"auto"`. */
+    cost_level?: number;
+    /** Default `true`. Set false to get an immediate `queued` response. */
+    wait?: boolean;
+    /** Seconds the server is allowed to block. Default `120`. Max `300`. */
+    timeout?: number;
+}
+interface ListRunsQuery {
+    limit?: number;
+    /**
+     * Opaque pagination cursor — `GET /chats/:id/runs` is cursor-paginated.
+     * Echo `pagination.next_cursor` from the previous page.
+     */
+    cursor?: string;
+    /** Filter by run lifecycle state. */
+    state?: AgentRunState;
+}
+interface StopChatInput {
+    mode?: "soft" | "hard";
+}
+interface ExportChatQuery {
+    format?: "markdown" | "text" | "json" | "pdf";
+}
+interface CopyChatToAgentInput {
+    agent_id: string;
+}
+interface CopyChatToWorkspaceInput {
+    workspace_id: string;
+    agent_id: string;
+}
+declare class ChatsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query?: ListChatsQuery, opts?: CallOptions): Promise<Chat[]>;
+    create(input: CreateChatInput, opts?: CallOptions): Promise<Chat>;
+    get(id: string, opts?: CallOptions): Promise<Chat>;
+    update(id: string, input: UpdateChatInput, opts?: CallOptions): Promise<Chat>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    archive(id: string, opts?: CallOptions): Promise<Chat>;
+    unarchive(id: string, opts?: CallOptions): Promise<Chat>;
+    restore(id: string, opts?: CallOptions): Promise<Chat>;
+    permanentDelete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /** `GET /chats/:id/cost` — token usage + spend snapshot. */
+    cost(id: string, opts?: CallOptions): Promise<ChatCost>;
+    /** `GET /chats/:id/message-costs` - per-message and per-run cost details. */
+    messageCosts(id: string, opts?: CallOptions): Promise<MessageCosts>;
+    /** `POST /chats/:id/stop` - request cancellation of the active run. */
+    stop(id: string, input?: StopChatInput, opts?: CallOptions): Promise<ChatStopResult>;
+    /** `GET /chats/:id/export` - stream a transcript as a Blob. */
+    export(id: string, query?: ExportChatQuery, opts?: CallOptions): Promise<Blob>;
+    copyToAgent(id: string, input: CopyChatToAgentInput, opts?: CallOptions): Promise<Chat>;
+    copyToWorkspace(id: string, input: CopyChatToWorkspaceInput, opts?: CallOptions): Promise<Chat>;
+    forkToWorkspace(id: string, opts?: CallOptions): Promise<Chat>;
+    /** `GET /chats/:id/messages` — paginated history. */
+    listMessages(id: string, query?: ListMessagesQuery, opts?: CallOptions): Promise<Message[]>;
+    /**
+     * `POST /chats/:id/messages` — send a user message + (optionally) wait
+     * for the assistant reply synchronously. Responds HTTP 201 with a
+     * `oneOf`: a completed `{status, chat_id, model_id, user_message_id,
+     * message}` or a pending `{status, pending_token, chat_id}`. The pending
+     * handle is `pending_token` — an opaque workflow handle, NOT a
+     * resourceId. See `SendMessageResult`.
+     */
+    sendMessage(id: string, input: SendMessageInput, opts?: CallOptions): Promise<SendMessageResult>;
+    /**
+     * `POST /chats/:id/messages/stream` — send a user message and stream the
+     * assistant reply token-by-token as Server-Sent Events. The real-time twin
+     * of {@link sendMessage}: same body, but instead of one finished JSON reply
+     * you get an `AsyncIterable` of raw SSE frames as the model generates.
+     *
+     * Each yielded `{ event, data }` has `data` as a JSON string — parse it per
+     * the frame's `event`:
+     *   - `token`   → `{ chat_id, message_id, text, reasoning? }` (`text` is the
+     *                 FULL accumulated snapshot — render by REPLACING, not
+     *                 appending)
+     *   - `message` → `{ chat_id, message_id, role }` (assistant row finalized)
+     *   - `done`    → `{ chat_id, message_id, status }` (terminal; loop ends)
+     *   - `heartbeat` → keep-alive ping, ignore.
+     *
+     *   for await (const frame of client.chats.stream(chatId, { content })) {
+     *     if (frame.event === "token") {
+     *       const { text } = JSON.parse(frame.data);
+     *       render(text);
+     *     }
+     *   }
+     *
+     * Delegates to the generic spec-driven executor, which turns the
+     * `text/event-stream` binary binding into the async iterable. Equivalent to
+     * `client.call("chat stream", input)`.
+     */
+    stream(id: string, input: StreamMessageInput, opts?: ExecuteCommandOptions): Promise<AsyncIterable<SseEvent>>;
+    /** `GET /chats/:id/runs` — model execution runs tied to this chat. */
+    listRuns(id: string, query?: ListRunsQuery, opts?: CallOptions): Promise<AgentRun[]>;
+    /**
+     * `POST /chats/:id/messages/:message_id/reprompt` — regenerate the
+     * assistant response to an existing user message. The original AI reply
+     * is preserved; a sibling assistant message is created so branching
+     * stays intact.
+     *
+     *   Before:  [User A] → [AI B]
+     *   After:   [User A] ─┬─ [AI B]
+     *                      └─ [AI C]   ← C.prevMessageId = A
+     *
+     * With `wait=true` (default) the server blocks until the new sibling is
+     * available; with `wait=false` returns `{ status: "pending", ... }` and
+     * the new message can be polled via `listMessages`.
+     */
+    repromptMessage(chatId: string, messageId: string, input?: RepromptMessageInput, opts?: CallOptions): Promise<RepromptResult>;
+}
+
+/**
+ * CodeRunsApi — `/api/v1/code-runs`.
+ *
+ * Two surfaces:
+ *   - `POST /code-runs` — execute a code file in a sandboxed Lambda
+ *     environment. Returns stdout, stderr, exit code, timing.
+ *   - `GET /code-runs` + `GET /code-runs/:id` — history browsing.
+ *
+ * Browser-apps use `runs.run()` to invoke a file owned by the user (e.g., a
+ * Python helper in the data folder) without needing a full computer.
+ */
+
+interface RunCodeInput {
+    file_id: string;
+    /** Hard upper bound on wall-clock runtime. Default 30s server-side. */
+    timeout_seconds?: number;
+    /**
+     * Environment variables passed to the running code. `IDAPT_API_KEY` is
+     * allowed. `AWS_*` and runtime-hijacking vars are stripped server-side.
+     */
+    env?: Record<string, string>;
+}
+/**
+ * `GET /v1/code-runs` query params. Cursor-paginated (opaque `cursor`);
+ * `backend` and `status` are closed enums.
+ */
+interface ListExecutionsQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+    backend?: ExecutionBackend;
+    status?: ExecutionRunStatus;
+}
+declare class CodeRunsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /**
+     * Execute a code file. Returns the full `ExecutionRun` row — `id`,
+     * `status`, `stdout`, `stderr`, `exit_code`, and the run timestamps —
+     * the same shape as `GET /code-runs/:id`.
+     */
+    run(input: RunCodeInput, opts?: CallOptions): Promise<ExecutionRun>;
+    /** List recent execution runs. */
+    list(query?: ListExecutionsQuery, opts?: CallOptions): Promise<ExecutionRun[]>;
+    /** Get a single execution run by id. */
+    get(id: string, opts?: CallOptions): Promise<ExecutionRun>;
+}
+
+/**
+ * ComputersApi — `/api/v1/computers`.
+ *
+ * Idapt manages daemon-connected computers (user-managed boxes and
+ * Idapt-provisioned VMs) as first-class workspace resources. This module is the
+ * flat surface over the entire `/api/v1/computers` tree.
+ *
+ * Verb groups (the route layout is `/computers/:id/<sub>`; flattened here so
+ * call sites don't have to instantiate per-computer factories):
+ *
+ *   - CRUD              — list / create pair token / get / update / delete
+ *   - Lifecycle         — archive / unarchive / start / hibernate /
+ *                          testConnection
+ *   - Exec              — exec (one-shot daemon command)
+ *   - Tmux              — tmux (re-attachable windows under `idapt` session)
+ *   - SFTP              — sftp (dispatcher), upload / download (binary)
+ *   - Ports             — listPorts / updatePort (managed only)
+ *   - Unix users        — listUsers / createUser / updateUser / deleteUser
+ *   - User env vars     — listUserEnvVars / createUserEnvVar /
+ *                          deleteUserEnvVar / setupUserEnv /
+ *                          checkUserEnvSetup / syncUserEnv / checkUserEnvSync
+ *   - Workspace links   — listWorkspaceLinks / linkWorkspace / unlinkWorkspace
+ *                          (share a computer's LOCAL INFERENCE into other
+ *                          workspaces; never shell / files / tunnels)
+ *   - Pair              — pair (daemon token bootstrap; bearer-overridden,
+ *                          mirrors the trigger-fire pattern)
+ *
+ * Permissions on every authenticated verb default to the caller's
+ * `computers:read` / `computers:write` scope. See `lib/computers/Computers.md`
+ * for the end-to-end computer model.
+ */
+
+interface ListComputersQuery {
+    workspace_id: string;
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+    include_archived?: boolean;
+}
+interface CreateComputerInput {
+    workspace_id: string;
+    /** Preferred computer name; the daemon row is created when this token is redeemed. */
+    intended_name?: string;
+}
+/**
+ * Result of `POST /v1/computers/pair-tokens` — a one-time pair token plus
+ * the install command. A pair token has no addressable id.
+ */
+interface CreateComputerResult {
+    token: string;
+    expires_at: string;
+    install_command: string;
+}
+/**
+ * `PATCH /v1/computers/{id}` body. `name` must match
+ * `^[a-z0-9](?:[a-z0-9]|-(?!-))*[a-z0-9]$` (max 64 chars) server-side.
+ */
+interface UpdateComputerInput {
+    name?: string;
+    description?: string | null;
+    icon?: string | null;
+    logging_level?: "minimal" | "standard" | "full";
+}
+interface ExecCommandInput {
+    command: string;
+    /** Hard upper bound; default 60s, max 900s. */
+    timeout_seconds?: number;
+    /** Run as a different POSIX user via `sudo -u`. */
+    user?: string;
+}
+type SftpOp = "list" | "stat" | "write" | "mkdir" | "rename" | "delete" | "chmod" | "chown";
+interface SftpInput {
+    op: SftpOp;
+    path: string;
+    /** `write` — utf-8 content. */
+    content?: string;
+    /** `rename` — target path. */
+    destination?: string;
+    /** `chmod` — octal mode string, e.g. "0755". */
+    mode?: string;
+    /** `chown` — owner name. */
+    owner?: string;
+    /** `chown` — optional group name (appended as `owner:group`). */
+    group?: string;
+}
+interface SftpListResult {
+    path: string;
+    entries: SftpEntry[];
+}
+interface SftpUploadInput {
+    /** Binary content. Browser `File`/`Blob` both work. */
+    file: Blob;
+    /** Destination path on the remote computer. */
+    path: string;
+    /** Relative path when uploading a folder tree; intermediate dirs created. */
+    relative_path?: string;
+    /** Conflict resolution. Default: `replace`. */
+    conflict_mode?: "replace" | "skip";
+}
+type TmuxOp = "list" | "run" | "capture" | "send" | "kill";
+interface TmuxInput {
+    op: TmuxOp;
+    /** Required for run/capture/send/kill. POSIX-safe shape. */
+    name?: string;
+    /** `run` — the shell command. */
+    command?: string;
+    /** `run` — optional `cd` prefix. */
+    working_dir?: string;
+    /** `send` — keys to inject (auto-followed by Enter). */
+    keys?: string;
+    /** `capture` — number of trailing lines to grab. Default 200. */
+    lines?: number;
+}
+interface PatchPortInput {
+    port: number;
+    protocol: string;
+    hidden?: boolean;
+    display_name?: string | null;
+    icon?: string | null;
+    description?: string | null;
+}
+interface CreateComputerUserInput {
+    username: string;
+    groups?: string[];
+    shell?: string;
+}
+interface UpdateComputerUserInput {
+    groups?: string[];
+}
+type CreateUserEnvVarInput = {
+    /** Credential file resourceId the value is sourced from. */
+    file_id: string;
+    name?: never;
+    value?: never;
+} | {
+    /** Env-var name to create and bind on the user. */
+    name: string;
+    /** Secret value. Stored server-side in a generated credential file. */
+    value: string;
+    file_id?: never;
+};
+/**
+ * `POST /v1/computers/pair` request body. All fields are snake_case on the
+ * wire.
+ */
+interface PairComputerInput {
+    /** One-time pair token minted by the user. */
+    token: string;
+    hostname: string;
+    os: string;
+    arch: string;
+    cli_version: string;
+    default_user: string;
+    host_kind: "server" | "desktop";
+    kernel_version?: string;
+}
+/**
+ * `POST /v1/computers/pair` result (unwrapped from `{data:{…}}`).
+ * `computer_id` is a **resourceId**, not a UUID.
+ */
+interface PairComputerResult {
+    computer_id: string;
+    computer_token: string;
+    domain: string;
+}
+/**
+ * One `computer_workspace` link — a computer shared INTO an additional
+ * workspace, granting LOCAL INFERENCE ONLY (never shell / files / tunnels).
+ * `workspace_resource_id` is the target workspace's public `ws_…` id.
+ */
+interface ComputerWorkspaceLink {
+    id: string;
+    computer_id: string;
+    workspace_id: string;
+    workspace_resource_id: string | null;
+    permissions: unknown[] | null;
+    created_by_actor_id: string;
+    created_at: number;
+    updated_at: number;
+}
+declare class ComputersApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query: ListComputersQuery, opts?: CallOptions): Promise<Computer[]>;
+    create(input: CreateComputerInput, opts?: CallOptions): Promise<CreateComputerResult>;
+    get(id: string, opts?: CallOptions): Promise<Computer>;
+    update(id: string, input: UpdateComputerInput, opts?: CallOptions): Promise<Computer>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    archive(id: string, opts?: CallOptions): Promise<Computer>;
+    unarchive(id: string, opts?: CallOptions): Promise<Computer>;
+    /** Wake a hibernated cloud computer. Errors with 409 from non-hibernated states. */
+    start(id: string, opts?: CallOptions): Promise<Computer>;
+    /** Stop a running cloud computer; preserves provider-local disk state. */
+    stop(id: string, opts?: CallOptions): Promise<Computer>;
+    /** Hibernate a running cloud computer; deallocates compute, snapshots state. */
+    hibernate(id: string, opts?: CallOptions): Promise<Computer>;
+    /**
+     * Daemon connectivity probe; returns a success flag + duration.
+     * Rate-limited per computer. `serverInfo` is a structured
+     * `{version, uptime_seconds}` object (was a free-form blob).
+     */
+    testConnection(id: string, opts?: CallOptions): Promise<{
+        success: boolean;
+        durationMs: number | null;
+        serverInfo: ComputerServerInfo | null;
+        error: string | null;
+    }>;
+    exec(id: string, input: ExecCommandInput, opts?: CallOptions): Promise<ComputerExecResult>;
+    /**
+     * tmux dispatcher. Each `op` returns a different shape — see the route
+     * docs for the per-op payload. Common case: `op: "run"` starts a window,
+     * `op: "capture"` reads its output.
+     */
+    tmux(id: string, input: TmuxInput, opts?: CallOptions): Promise<Record<string, unknown>>;
+    /** Convenience over `tmux({ op: "list" })`. */
+    listTmuxWindows(id: string, opts?: CallOptions): Promise<TmuxWindow[]>;
+    /**
+     * Unified SFTP dispatcher. Returns op-shaped payload. For streaming
+     * uploads/downloads use `sftpUpload` / `sftpDownload`.
+     */
+    sftp(id: string, input: SftpInput, opts?: CallOptions): Promise<Record<string, unknown>>;
+    /** Convenience: `sftp({op:"list"})` returning the entries array directly. */
+    sftpList(id: string, path: string, opts?: CallOptions): Promise<SftpListResult>;
+    /**
+     * Multipart upload of a file/folder member. Falls back to single-file mode
+     * when `relative_path` is omitted.
+     */
+    sftpUpload(id: string, input: SftpUploadInput, opts?: CallOptions): Promise<Record<string, unknown>>;
+    /**
+     * Stream a remote file (or a folder as `tar.gz`) as a `Blob`. The server
+     * sends the real MIME type on `Content-Type`.
+     */
+    sftpDownload(id: string, remotePath: string, opts?: CallOptions): Promise<Blob>;
+    listPorts(id: string, query?: {
+        refresh?: boolean;
+    }, opts?: CallOptions): Promise<{
+        ports: ComputerPort[];
+        discoveryStatus: string;
+        discoveryError: string | null;
+    }>;
+    updatePort(id: string, input: PatchPortInput, opts?: CallOptions): Promise<ComputerPort>;
+    /**
+     * List the computer's Unix users. The v1 contract returns a list envelope
+     * — `data` is the user array, with `current_user`, `has_root_access` and
+     * `has_sudo_access` as sibling top-level keys. This convenience method
+     * returns just the array; use `listUsersWithMeta` for the access flags.
+     */
+    listUsers(id: string, opts?: CallOptions): Promise<ComputerUser[]>;
+    /**
+     * Like `listUsers` but returns the full v1 list envelope, including the
+     * `current_user` daemon user and the `has_root_access` / `has_sudo_access`
+     * capability flags.
+     */
+    listUsersWithMeta(id: string, opts?: CallOptions): Promise<ListEnvelope<ComputerUser> & {
+        current_user?: string | null;
+        has_root_access?: boolean;
+        has_sudo_access?: boolean;
+    }>;
+    /** Fetch one Unix user by username (`GET /v1/computers/{id}/users/{username}`). */
+    getUser(id: string, username: string, opts?: CallOptions): Promise<ComputerUser>;
+    /**
+     * Create a Unix user. The user fields are returned directly under `data`.
+     * Responds 201 on creation, 200 when the user already existed.
+     */
+    createUser(id: string, input: CreateComputerUserInput, opts?: CallOptions): Promise<ComputerUser>;
+    /** Update a Unix user. The user fields are returned directly under `data`. */
+    updateUser(id: string, username: string, input: UpdateComputerUserInput, opts?: CallOptions): Promise<ComputerUser>;
+    deleteUser(id: string, username: string, opts?: CallOptions): Promise<DeletedResponse>;
+    listUserEnvVars(id: string, username: string, opts?: CallOptions): Promise<ComputerEnvVar[]>;
+    createUserEnvVar(id: string, username: string, input: CreateUserEnvVarInput, opts?: CallOptions): Promise<ComputerEnvVar>;
+    /**
+     * Remove an env-var binding from a user. A binding is addressed by its
+     * env-var `name` (the route segment is `{name}`, not a UUID).
+     */
+    deleteUserEnvVar(id: string, username: string, name: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /** Bootstrap `~/.idapt-env` + `.bashrc` sourcing on a user. Idempotent. */
+    setupUserEnv(id: string, username: string, opts?: CallOptions): Promise<Record<string, unknown>>;
+    checkUserEnvSetup(id: string, username: string, opts?: CallOptions): Promise<Record<string, unknown>>;
+    /** Rewrite the computer's `~/.idapt-env` from the DB-recorded bindings. */
+    syncUserEnv(id: string, username: string, opts?: CallOptions): Promise<Record<string, unknown>>;
+    checkUserEnvSync(id: string, username: string, opts?: CallOptions): Promise<Record<string, unknown>>;
+    /**
+     * List the workspaces a computer's LOCAL INFERENCE is shared into. The home
+     * workspace is never listed (it already has full access). The route returns
+     * the links under a `links` key (not a standard list envelope).
+     */
+    listWorkspaceLinks(id: string, opts?: CallOptions): Promise<ComputerWorkspaceLink[]>;
+    /**
+     * Share a computer's LOCAL INFERENCE into another workspace (never shell /
+     * files / tunnels). `workspaceId` is the target workspace's `ws_…`
+     * resourceId or slug. Requires EDIT on the computer's home workspace and
+     * membership of the target. Rejects the home workspace and duplicates.
+     */
+    linkWorkspace(id: string, workspaceId: string, opts?: CallOptions): Promise<ComputerWorkspaceLink>;
+    /**
+     * Stop sharing a computer's local inference into a workspace. `workspaceId`
+     * is the target workspace's `ws_…` resourceId. Idempotent — unlinking a
+     * non-existent link still succeeds.
+     */
+    unlinkWorkspace(id: string, workspaceId: string, opts?: CallOptions): Promise<{
+        unlinked: boolean;
+    }>;
+    /**
+     * Redeem a one-time pair token for a long-lived computer identity. The
+     * token itself is the auth — we swap the bearer for the token on this
+     * call only (same pattern as `triggers.fire`).
+     *
+     * Used by `idapt up --token` to bootstrap a daemon. The request body is
+     * snake_case; the response is wrapped in the standard `{data:{…}}`
+     * envelope. `computer_id` is a resourceId.
+     */
+    pair(input: PairComputerInput, opts?: CallOptions): Promise<PairComputerResult>;
+}
+
+/**
+ * DatastoreApi — `/api/v1/datastore` (the KV data plane).
+ *
+ * Workspace-scoped key/value store. Entries live under a `namespace` (a bucket
+ * you pick) and a `key`. Surfaced as `client.kv.*` on `IdaptClient`.
+ */
+
+interface DatastoreListOptions extends CallOptions {
+    /** Only keys starting with this prefix. */
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface DatastoreSetOptions extends CallOptions {
+    /** Seconds until the entry expires; omit for no expiry. */
+    ttlSeconds?: number;
+}
+declare class DatastoreApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /** List keys in a namespace (prefix-filterable). */
+    list(namespace: string, opts?: DatastoreListOptions): Promise<{
+        key: string;
+    }[]>;
+    /** Read a KV entry. */
+    get(namespace: string, key: string, opts?: CallOptions): Promise<DatastoreEntry>;
+    /** Upsert a KV entry (optionally with a TTL). */
+    set(namespace: string, key: string, value: unknown, opts?: DatastoreSetOptions): Promise<DatastoreEntry>;
+    /** Delete a KV entry (idempotent). */
+    delete(namespace: string, key: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /** Atomically add `by` (default 1) to a numeric counter. */
+    increment(namespace: string, key: string, by?: number, opts?: CallOptions): Promise<{
+        key: string;
+        value: number;
+    }>;
+    /** List the namespaces in the workspace. */
+    listNamespaces(opts?: CallOptions): Promise<string[]>;
+    /** Read several keys at once. */
+    batchGet(namespace: string, keys: string[], opts?: CallOptions): Promise<DatastoreEntry[]>;
+    /** Upsert several entries at once. */
+    batchSet(namespace: string, entries: {
+        key: string;
+        value: unknown;
+        ttlSeconds?: number | null;
+    }[], opts?: CallOptions): Promise<number>;
+    /** Delete several keys at once; returns the count removed. */
+    batchDelete(namespace: string, keys: string[], opts?: CallOptions): Promise<number>;
+}
+
+/**
+ * DocsApi — `GET /api/v1/docs`.
+ *
+ * Returns the computer-readable OpenAPI 3.1 spec for the v1 API. Useful for
+ * tools that generate clients / validators at runtime. Most consumers of
+ * this SDK don't need it — the typed wrappers cover the same surface.
+ */
+
+declare class DocsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /**
+     * Fetch the OpenAPI spec as a plain object. Shape is `OpenAPI.Document`
+     * from the standard spec — typed as `Record<string, unknown>` here so
+     * consumers can narrow as needed without pulling in an openapi-types
+     * dependency.
+     */
+    get(opts?: CallOptions): Promise<Record<string, unknown>>;
+}
+
+/**
+ * FilesApi — the full `/api/v1/drive/files` surface for app code that operates
+ * on arbitrary file ids (not just the sandboxed folders exposed via
+ * `client.app` / `client.data`).
+ *
+ * Use when:
+ *   - The app has elevated `files:*` permission and wants to touch files
+ *     outside its `.app-data` scope.
+ *   - You need create-folder / move / run endpoints with a workspace_id /
+ *     parent_id you choose yourself.
+ *
+ * For "save preferences in my data folder", prefer `client.data.set(name)`
+ * — it handles name→id resolution and OCC for you.
+ *
+ * All HTTP details live in `_files-core.ts` so DataFolder / AppFolder share
+ * exactly the same wire behaviour.
+ */
+
+declare class FilesApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query?: ListFilesQuery, opts?: CallOptions): Promise<File$1[]>;
+    /** Multipart upload a Blob/File. Returns the partial file record. */
+    upload(input: UploadInput, opts?: CallOptions): Promise<FileUploadResult>;
+    /**
+     * Fetch a file's raw text content. Use for text-like files (source code,
+     * Markdown, JSON strings). For binary content (images, PDFs, zips) use
+     * `getBlob()` instead — `getText()` will UTF-8 decode and corrupt bytes.
+     */
+    getText(id: string, opts?: CallOptions): Promise<string>;
+    /**
+     * Fetch a file's raw bytes as a Blob. The server sends the real MIME
+     * type on `Content-Type`; the returned Blob's `.type` reflects it.
+     */
+    getBlob(id: string, opts?: CallOptions): Promise<Blob>;
+    /**
+     * Patch file metadata or content. Supports `expectedUpdatedAt` for
+     * optimistic concurrency — pass it when you know the version you read.
+     */
+    patch(id: string, input: PatchFileInput, opts?: WriteOptions): Promise<File$1>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    restore(id: string, opts?: CallOptions): Promise<File$1>;
+    permanentDelete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /**
+     * Idempotent create-or-get a folder. Returns the existing folder (with
+     * `200`) or the new one (`201`) — consumers don't need to distinguish.
+     */
+    createFolder(input: CreateFolderInput, opts?: CallOptions): Promise<File$1>;
+    move(id: string, parentId: string | null, opts?: CallOptions): Promise<File$1>;
+    /**
+     * Execute a code file (js/ts/py/sh) in a sandboxed Lambda. Returns the
+     * full `ExecutionRun` record (status, stdout/stderr, exit code, timestamps).
+     */
+    run(id: string, input?: RunFileInput, opts?: CallOptions): Promise<ExecutionRun>;
+}
+
+/**
+ * GuideApi — `GET /api/v1/guide`.
+ *
+ * Returns the canonical SKILL.md — Markdown instructions that LLMs (or
+ * other browser-apps) can load to learn what the idapt API offers. Served as
+ * a JSON envelope (`{ data: { content, format } }`).
+ */
+
+/** Payload of `GET /v1/skill` — the SKILL.md body plus its format tag. */
+interface GuideContent {
+    /** The SKILL.md document body. */
+    content: string;
+    /** Content format — `"markdown"` today. */
+    format: string;
+}
+declare class GuideApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /**
+     * Fetch the SKILL.md document. Returns `{ content, format }` — the route
+     * responds with a JSON envelope, not raw text.
+     */
+    get(opts?: CallOptions): Promise<GuideContent>;
+}
+
+/**
+ * ImagesApi — `/api/v1/images/*`.
+ *
+ * Two endpoints:
+ *   - `GET /images/models`        → catalogue of image models. Each item is
+ *                                   `{id, display_name, provider, modality}`
+ *                                   plus image-specific fields.
+ *   - `POST /images/generations`  → generate an image, returns a file ref.
+ *                                   Responds HTTP 201 (resource created).
+ *
+ * `generate()` writes the output into the caller's workspace (required) at
+ * an optional path; the response includes a `file_id` you can turn around
+ * and pass to `files.get(id)` for the bytes, or use `url` for a signed
+ * download link.
+ */
+
+interface GenerateImageInput {
+    prompt: string;
+    workspace_id: string;
+    model?: string;
+    output_path?: string;
+    reference_image_ids?: string[];
+    reference_image_paths?: string[];
+    aspect_ratio?: string;
+}
+declare class ImagesApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    listModels(opts?: CallOptions): Promise<ImageModel[]>;
+    /** Generate an image. Responds HTTP 201 with the written file ref under `data`. */
+    generate(input: GenerateImageInput, opts?: CallOptions): Promise<ImageGenerationResult>;
+}
+
+/**
+ * ModelsApi — `GET /api/v1/models`.
+ *
+ * Returns the catalogue of LLMs available to the authenticated user.
+ * Pricing and capability fields drive the model-picker UX in any app that
+ * lets users swap models.
+ */
+
+declare class ModelsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(opts?: CallOptions): Promise<LLMModel[]>;
+}
+
+/**
+ * NotificationsApi — `/api/v1/notifications`.
+ *
+ * Notifications are per-recipient rows attached to underlying notification
+ * "events". The SDK exposes only the per-recipient view — events themselves
+ * are an internal audit surface.
+ *
+ * Three sub-surfaces on the same module for ergonomics:
+ *   - per-row verbs: list, get, markRead, archive, unarchive, delete
+ *   - bulk: readAll
+ *   - settings: getConfig / updateConfig (toasts, quiet hours, digest)
+ *   - matrix: getPreferences / updatePreferences (per-(type, subtype?, channel))
+ *   - send: send a notification to workspace members (admin/owner verb)
+ *
+ * `id` parameters are notification recipient resourceIds. Resolution of
+ * profile/workspace FKs to resourceIds is handled server-side; both lists
+ * and singles come back already in wire shape.
+ */
+
+interface ListNotificationsQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+    unread_only?: boolean;
+    archived_only?: boolean;
+    type?: string;
+    subtype?: string;
+    workspace_id?: string;
+    search?: string;
+}
+interface UpdateNotificationInput {
+    /**
+     * Mark the row read. Only `true` is accepted — the v1 contract does not
+     * support reverting a row to unread via this field.
+     */
+    is_read?: true;
+    /** `true` → archive, `false` → unarchive. */
+    archived?: boolean;
+}
+type NotificationAudience = string[] | "all_members" | "admins" | "owner";
+interface SendNotificationInput {
+    workspace_id: string;
+    title: string;
+    message?: string;
+    /**
+     * One of:
+     *   - An array of profile resourceIds — only those people get the row
+     *   - `"all_members" | "admins" | "owner"` — broadcast within the workspace
+     *
+     * Exactly one form must be supplied.
+     */
+    audience: NotificationAudience;
+    channels?: ("in_app" | "email" | "web_push")[];
+    urgency?: "low" | "normal" | "high";
+    /** Idempotency tag — repeat calls with the same key dedupe. */
+    dedup_key?: string;
+    data?: Record<string, unknown>;
+    /** Click-through target. See `backend/platform/notifications/src/internal/notifications/deep-links.ts`. */
+    deep_link?: Record<string, unknown>;
+}
+interface SendNotificationResult {
+    recipientCount: number;
+    deduped: boolean;
+    deepLink?: Record<string, unknown>;
+}
+/** Single entry in the bulk-update payload for the preferences matrix. */
+interface NotificationPreferenceUpdate {
+    type: string;
+    subtype?: string;
+    channel: "in_app" | "email" | "web_push";
+    enabled: boolean;
+}
+declare class NotificationsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /**
+     * List notification rows. Returns the `data` array directly; the
+     * unfiltered unread tally lives at the TOP LEVEL of the wire envelope
+     * (`unread_count`, a sibling of `data`/`pagination`) — use `listWithMeta`
+     * when you need it.
+     */
+    list(query?: ListNotificationsQuery, opts?: CallOptions): Promise<Notification[]>;
+    /**
+     * Like `list()` but returns the full envelope so callers can read the
+     * top-level `unread_count` (e.g. to drive an unread badge).
+     */
+    listWithMeta(query?: ListNotificationsQuery, opts?: CallOptions): Promise<ListEnvelope<Notification> & {
+        unread_count: number;
+    }>;
+    get(id: string, opts?: CallOptions): Promise<Notification>;
+    /**
+     * PATCH a single recipient row. The body accepts only the `is_read` and
+     * `archived` booleans; at least one must be supplied (422 otherwise).
+     * Returns the full updated `Notification`.
+     */
+    update(id: string, input: UpdateNotificationInput, opts?: CallOptions): Promise<Notification>;
+    /** Shorthand for `update(id, { is_read: true })`. */
+    markRead(id: string, opts?: CallOptions): Promise<{
+        id: string;
+        type: string;
+        title: string;
+        is_read: boolean;
+        created_at: string;
+        subtype?: string | null | undefined;
+        message?: string | null | undefined;
+        data?: Record<string, unknown> | null | undefined;
+        group_key?: string | null | undefined;
+        workspace_id?: string | null | undefined;
+        sender_kind?: string | null | undefined;
+        sender_actor_id?: string | null | undefined;
+        sender_agent_id?: string | null | undefined;
+        audience?: string | string[] | null | undefined;
+        read_at?: string | null | undefined;
+        archived_at?: string | null | undefined;
+    }>;
+    /** Shorthand for `update(id, { archived: true })`. */
+    archive(id: string, opts?: CallOptions): Promise<{
+        id: string;
+        type: string;
+        title: string;
+        is_read: boolean;
+        created_at: string;
+        subtype?: string | null | undefined;
+        message?: string | null | undefined;
+        data?: Record<string, unknown> | null | undefined;
+        group_key?: string | null | undefined;
+        workspace_id?: string | null | undefined;
+        sender_kind?: string | null | undefined;
+        sender_actor_id?: string | null | undefined;
+        sender_agent_id?: string | null | undefined;
+        audience?: string | string[] | null | undefined;
+        read_at?: string | null | undefined;
+        archived_at?: string | null | undefined;
+    }>;
+    /** Shorthand for `update(id, { archived: false })`. */
+    unarchive(id: string, opts?: CallOptions): Promise<{
+        id: string;
+        type: string;
+        title: string;
+        is_read: boolean;
+        created_at: string;
+        subtype?: string | null | undefined;
+        message?: string | null | undefined;
+        data?: Record<string, unknown> | null | undefined;
+        group_key?: string | null | undefined;
+        workspace_id?: string | null | undefined;
+        sender_kind?: string | null | undefined;
+        sender_actor_id?: string | null | undefined;
+        sender_agent_id?: string | null | undefined;
+        audience?: string | string[] | null | undefined;
+        read_at?: string | null | undefined;
+        archived_at?: string | null | undefined;
+    }>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /**
+     * Mark every unread, non-archived, non-deleted notification as read.
+     * Resolves once the bulk update lands — the v1 response is an empty
+     * `{ data: {} }` envelope.
+     */
+    readAll(opts?: CallOptions): Promise<void>;
+    /**
+     * Send a notification to workspace members. The caller must be an admin/owner
+     * of the workspace; `recipient_ids` (profile resourceIds) and the broadcast
+     * targets are mutually exclusive — pass one via `audience`.
+     */
+    send(input: SendNotificationInput, opts?: CallOptions): Promise<SendNotificationResult>;
+    /**
+     * Fetch the per-user toast/sound/quiet-hours/digest config. The response
+     * is flat — the config object IS `data`, with no inner `{config}` wrapper.
+     */
+    getConfig(opts?: CallOptions): Promise<NotificationConfig>;
+    /** PATCH a subset of the config. Returns the full flat config. */
+    updateConfig(input: Partial<NotificationConfig>, opts?: CallOptions): Promise<NotificationConfig>;
+    /**
+     * Fetch the (type, subtype?, channel) preference matrix. The response is
+     * flat — `data` IS the preference array, with no inner `{preferences}`
+     * wrapper.
+     */
+    getPreferences(opts?: CallOptions): Promise<NotificationPreference[]>;
+    /**
+     * Bulk-update preferences. Each entry sets one (type, subtype?, channel)
+     * row. Empty `updates[]` → 422. Returns the full flat preference array.
+     */
+    updatePreferences(updates: NotificationPreferenceUpdate[], opts?: CallOptions): Promise<NotificationPreference[]>;
+}
+
+/**
+ * ProviderEndpointsApi — `/api/v1/ai-gateway/provider-endpoints`.
+ *
+ * User-owned BYOK and daemon-local endpoints used by model routing. Provider
+ * secrets are write-only: create/update accept `api_key`, but reads only expose
+ * `api_key_preview`.
+ */
+
+interface ProviderEndpointModelMappingInput {
+    /** Idapt model id, for example `openai/gpt-5.4`. */
+    model_id: string;
+    /** Upstream provider model id. Defaults server-side to `model_id`. */
+    api_model_id: string;
+}
+interface CreateProviderEndpointInput {
+    kind?: ProviderEndpointKind;
+    provider_key?: ProviderEndpointProviderKey;
+    connection_type?: ProviderEndpointConnectionType;
+    display_name: string;
+    api_key?: string;
+    transport?: ProviderEndpointTransport;
+    runtime?: ProviderEndpointRuntime | null;
+    protocol?: ProviderEndpointProtocol | null;
+    computer_id?: string | null;
+    local_base_url?: string | null;
+    visibility?: ProviderEndpointVisibility;
+    base_url?: string | null;
+    default_for_kind?: boolean;
+    default_modalities?: ProviderEndpointModality[];
+    model_mappings?: ProviderEndpointModelMappingInput[];
+}
+type UpdateProviderEndpointInput = Partial<Omit<CreateProviderEndpointInput, "kind">> & {
+    enabled?: boolean;
+};
+declare class ProviderEndpointsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(opts?: CallOptions): Promise<ProviderEndpoint[]>;
+    presets(opts?: CallOptions): Promise<ManagedProviderPreset[]>;
+    create(input: CreateProviderEndpointInput, opts?: CallOptions): Promise<ProviderEndpoint>;
+    update(id: string, input: UpdateProviderEndpointInput, opts?: CallOptions): Promise<ProviderEndpoint>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    test(id: string, opts?: CallOptions): Promise<ProviderEndpointTestResult>;
+}
+
+/**
+ * RealtimeApi — `/api/v1/realtime` (broadcast + presence + live subscribe).
+ *
+ * Channels authorize by the resource they name (`ws:{wsResId}:…`,
+ * `table:{collResId}`, `app:{appResId}`). Surfaced as `client.realtime.*`.
+ *
+ * Two surfaces:
+ *   - **control** (`broadcast` / `heartbeat` / `presence`) — plain JSON calls.
+ *   - **live** (`subscribe`) — opens an authenticated SSE `fetch`-stream and
+ *     pushes each frame to a callback, auto-resuming via `Last-Event-ID`.
+ *
+ * `subscribe` deliberately uses `requestRaw` (a `fetch`-stream) rather than a
+ * native `EventSource`. `EventSource` can't set an `Authorization` header, so it
+ * only works same-origin via the session cookie; a `fetch`-stream rides the
+ * SDK's existing auth (static bearer, app-key cookie, OR minted-bearer) and
+ * therefore works isomorphically in node and the browser. The trade-off is we
+ * own reconnect/backoff (below) instead of the browser's built-in EventSource
+ * retry.
+ */
+
+interface PresenceEntry {
+    principal_id: string;
+    meta: Record<string, unknown>;
+    last_seen: number;
+}
+interface PresenceHeartbeatOptions extends CallOptions {
+    /** Arbitrary presence metadata (name, cursor, …). */
+    meta?: Record<string, unknown>;
+    /** Seconds the presence entry stays live without a refresh. */
+    ttlSeconds?: number;
+}
+/** A single realtime event handed to a {@link RealtimeApi.subscribe} callback. */
+interface RealtimeEvent {
+    /** The channel the event belongs to. */
+    channel: string;
+    /**
+     * Event type. Durable changes carry the publisher's type (e.g.
+     * `record:created`); broadcasts are `"broadcast"`; transport signals are
+     * `"session:gap"` / `"heartbeat"`.
+     */
+    type: string;
+    /** The payload — the change `data`, the broadcast message, or `null`. */
+    data: unknown;
+    /** Resume cursor (Redis stream id) — present only on durable change frames. */
+    id?: string;
+}
+interface SubscribeOptions {
+    /** Called on a stream/parse/network error (the SDK still auto-reconnects). */
+    onError?: (err: Error) => void;
+    /** Initial resume cursor (Redis stream id) for the first connect. */
+    lastEventId?: string;
+    /**
+     * Abort the subscription. Equivalent to calling the returned unsubscribe fn;
+     * provided for callers that already thread an `AbortSignal`.
+     */
+    signal?: AbortSignal;
+}
+/** A per-channel handle composing the realtime verbs for one channel. */
+interface ChannelHandle {
+    /** The channel key. */
+    readonly key: string;
+    /** Subscribe to this channel's live changes + broadcasts. */
+    subscribe(onEvent: (event: RealtimeEvent) => void, opts?: SubscribeOptions): () => void;
+    /** Send an ephemeral broadcast to this channel's subscribers. */
+    broadcast(message: unknown, opts?: CallOptions): Promise<{
+        ok: boolean;
+    }>;
+    /** List who is currently present on this channel. */
+    presence(opts?: CallOptions): Promise<PresenceEntry[]>;
+    /** Record/refresh the caller's presence (TTL heartbeat). */
+    heartbeat(opts?: PresenceHeartbeatOptions): Promise<{
+        ok: boolean;
+    }>;
+}
+declare class RealtimeApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /** Send an ephemeral message to a channel's current subscribers. */
+    broadcast(channel: string, message: unknown, opts?: CallOptions): Promise<{
+        ok: boolean;
+    }>;
+    /** Record/refresh the caller's presence on a channel (TTL heartbeat). */
+    heartbeat(channel: string, opts?: PresenceHeartbeatOptions): Promise<{
+        ok: boolean;
+    }>;
+    /** List who is currently present on a channel. */
+    presence(channel: string, opts?: CallOptions): Promise<PresenceEntry[]>;
+    /**
+     * Open an SSE stream for one or more channels' durable changes + ephemeral
+     * broadcasts. `onEvent` fires for every change/broadcast frame; heartbeat and
+     * transport-only signals are NOT surfaced (they keep the socket warm). Returns
+     * an unsubscribe function — call it (or abort `opts.signal`) to close.
+     *
+     * The stream auto-reconnects with capped exponential backoff and resumes from
+     * the last seen change id (so durable changes are not missed across a drop).
+     */
+    subscribe(channels: string[], onEvent: (event: RealtimeEvent) => void, opts?: SubscribeOptions): () => void;
+    /**
+     * A per-channel handle bundling subscribe + broadcast + presence + heartbeat
+     * for one channel, so callers don't repeat the key:
+     *
+     *   const ch = client.realtime.channel("table:col_123");
+     *   const stop = ch.subscribe((e) => render(e));
+     *   await ch.broadcast({ cursor: { x, y } });
+     */
+    channel(key: string): ChannelHandle;
+}
+
+/**
+ * SearchApi — `GET /api/v1/search`.
+ *
+ * Full-text search across the user's accessible content (files, chats,
+ * agents, etc.). Results are loosely shaped — caller narrows via `.type`.
+ */
+
+interface SearchInput {
+    q: string;
+    /** Page size — capped at 50 server-side for search (default 50). */
+    limit?: number;
+    /**
+     * Opaque pagination cursor — `GET /v1/search` is cursor-paginated.
+     * Echo `pagination.next_cursor` from the previous page.
+     */
+    cursor?: string;
+    /** Comma-separated source filter, e.g. `file` or `chat_message,chat`. */
+    source?: string;
+    /** File type filter when searching files. */
+    type?: "documents" | "images" | "videos" | "audio" | "folders";
+    /** Workspace resourceId to scope results. */
+    workspace_id?: string;
+    /** Chat-only search mode when source is omitted. */
+    chat_mode?: "title" | "content";
+}
+declare class SearchApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    search(input: SearchInput, opts?: CallOptions): Promise<SearchResult[]>;
+}
+
+/**
+ * SecretsApi — `/api/v1/secrets` (Idapt Secrets).
+ *
+ * Flat, workspace-scoped secrets. `workspace_id` is optional on `list`/`create`
+ * and defaults to the caller's personal workspace (same posture as the rest of
+ * v1). The plaintext value is NEVER returned by list/get/create/update — only a
+ * masked `value_preview`. The single value-returning call is `reveal`, which is
+ * session-only, audited, and rate-limited server-side (and never available to
+ * agents). To mount a secret into a runtime, reference it by name; do not pull
+ * the value client-side.
+ *
+ * Surfaced as `client.secrets.*` on `IdaptClient`.
+ */
+
+interface ListSecretsOptions extends CallOptions {
+    /** Workspace resourceId. Omit for the caller's personal workspace. */
+    workspaceId?: string;
+}
+interface CreateSecretInput {
+    name: string;
+    value: string;
+    description?: string | null;
+    /** Content classification; derived from the name when omitted. */
+    type?: "generic" | "password" | "api_key" | "ssh_private_key" | "ssh_public_key";
+    /** Target workspace resourceId. Omit for the personal workspace. */
+    workspace_id?: string;
+}
+interface UpdateSecretInput {
+    /** Pass a new plaintext to ROTATE the secret. Omit to leave unchanged. */
+    value?: string;
+    description?: string | null;
+}
+declare class SecretsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(opts?: ListSecretsOptions): Promise<Secret[]>;
+    get(secretId: string, opts?: CallOptions): Promise<Secret>;
+    create(input: CreateSecretInput, opts?: CallOptions): Promise<Secret>;
+    update(secretId: string, input: UpdateSecretInput, opts?: CallOptions): Promise<Secret>;
+    delete(secretId: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /**
+     * Reveal a secret's plaintext value. Session-authenticated callers only (not
+     * API keys), audited, and rate-limited. Returns the decrypted `value`.
+     */
+    reveal(secretId: string, opts?: CallOptions): Promise<SecretWithValue>;
+}
+
+/**
+ * SettingsApi — `/api/v1/settings`.
+ *
+ * Account-level preferences: profile display name, slug, public visibility,
+ * Hub publisher username, AI auto-compact opt-in, analytics/marketing consent.
+ *
+ * Slug renames go through the dedicated rename pipeline server-side
+ * (uniqueness + cooldown + audit). Pass `slug` in `update()`; the route
+ * dispatches to the rename path under the hood. A rejected slug surfaces
+ * as an `invalid_request` (422) error.
+ *
+ * UI-only state (sidebar hints, theme, modal counters) is intentionally
+ * NOT on the public surface.
+ */
+
+interface UpdateSettingsInput {
+    name?: string | null;
+    /** Lowercase 3–30 chars, `[a-z0-9-]`. Routed through the rename pipeline. */
+    slug?: string;
+    is_public?: boolean;
+    is_auto_compact_enabled?: boolean;
+    consent_analytics?: boolean;
+    consent_marketing?: boolean;
+    consent_decided_at?: string;
+    locale?: string | null;
+    icon?: string | null;
+    github_username?: string | null;
+}
+declare class SettingsApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    get(opts?: CallOptions): Promise<Settings>;
+    update(input: UpdateSettingsInput, opts?: CallOptions): Promise<Settings>;
+}
+
+/**
+ * SharingApi — `/api/v1/shares` + `/api/v1/shared-with-me`.
+ *
+ * One unified surface for managing shares across every resource type
+ * (chat / agent / file / workspace) — the v1 route is intentionally a
+ * single endpoint that discriminates by `resource_type`, rather than
+ * `/v1/chats/:id/shares` etc. The SDK mirrors that shape so we keep
+ * the wire and the SDK at parity.
+ *
+ *   list({ resource_type, resource_id })    → GET    /v1/shares  (query)
+ *   add({ resource_type, resource_id, ... }) → POST   /v1/shares  (body)
+ *   update({ ... })                         → PATCH  /v1/shares  (triple
+ *                                              on query, {permission} body)
+ *   remove({ ... })                         → DELETE /v1/shares  (triple
+ *                                              on query, no body)
+ *   listSharedWithMe(query)                  → GET    /v1/shared-with-me
+ *
+ * Grantee actor ids on the wire are profile resourceIds. The route
+ * resolves them to internal uuids server-side. A share has no standalone
+ * `id` — it is keyed by its `(resource_type, resource_id,
+ * grantee_actor_id)` triple. PATCH/DELETE carry that triple as QUERY
+ * params (not a JSON body); `remove()` echoes the triple back at the
+ * top level of the response.
+ */
+
+interface ListSharesQuery {
+    resource_type: ShareResourceType;
+    resource_id: string;
+}
+interface CreateShareInput {
+    resource_type: ShareResourceType;
+    resource_id: string;
+    /** Grantee profile resourceId. */
+    grantee_actor_id: string;
+    permission: SharePermission;
+}
+type UpdateShareInput = CreateShareInput;
+interface RemoveShareInput {
+    resource_type: ShareResourceType;
+    resource_id: string;
+    grantee_actor_id: string;
+}
+interface ListSharedWithMeQuery {
+    resource_type?: ShareResourceType;
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+}
+declare class SharingApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query: ListSharesQuery, opts?: CallOptions): Promise<Share[]>;
+    add(input: CreateShareInput, opts?: CallOptions): Promise<Share>;
+    /**
+     * Update a share's permission. The keying triple
+     * (`resource_type`, `resource_id`, `grantee_actor_id`) goes on the QUERY
+     * string; the request BODY carries only `{ permission }`.
+     */
+    update(input: UpdateShareInput, opts?: CallOptions): Promise<Share>;
+    /**
+     * Remove a share. The keying triple goes on the QUERY string; the
+     * request takes NO body. The response is the removed triple at the TOP
+     * LEVEL — `{ deleted, resource_type, resource_id, grantee_actor_id }` —
+     * not nested under `data` (a share has no standalone id).
+     */
+    remove(input: RemoveShareInput, opts?: CallOptions): Promise<ShareDeletedResult>;
+    /**
+     * List resources others have shared with the caller. Omit `resource_type`
+     * for the unified view across chats / agents / files / workspaces.
+     */
+    listSharedWithMe(query?: ListSharedWithMeQuery, opts?: CallOptions): Promise<SharedWithMeItem[]>;
+}
+
+/**
+ * StoreApi — `/api/v1/store/*`.
+ *
+ * Hub / store surface for browsing and installing community items: skills,
+ * agent templates, computer images, workspace templates.
+ *
+ * Both verbs are feature-gated by FF42 (Hub) server-side. With the flag
+ * OFF the routes 404; the SDK relays that as a `NotFoundError`. The CLI's
+ * `idapt store` tree gates on the same flag client-side, so visibility of
+ * the verbs in `idapt help` matches what the server actually accepts.
+ */
+
+interface SearchStoreQuery {
+    q?: string;
+    type?: "all" | StoreItemType;
+    sort?: "popular" | "recent" | "updated";
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+}
+interface InstallStoreItemInput {
+    /** Destination workspace resourceId. */
+    workspace_id: string;
+    folder_name?: string;
+    /** Parent file resourceId to land the installed folder under. */
+    target_parent_id?: string | null;
+}
+declare class StoreApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /**
+     * Search the hub. Open envelope — items are heterogeneous (skills carry
+     * version/license, agents carry icons/prompts, computer templates carry
+     * sizing) so we surface them as `StoreItem` with an open index signature.
+     */
+    search(query?: SearchStoreQuery, opts?: CallOptions): Promise<StoreItem[]>;
+    /**
+     * Install a hub item into one of the caller's workspaces. Returns whatever
+     * the per-template installer produces (folder ids, agent ids, ...) —
+     * `StoreInstallResult` carries the common fields and leaves the rest
+     * open.
+     */
+    install(resourceId: string, input: InstallStoreItemInput, opts?: CallOptions): Promise<StoreInstallResult>;
+}
+
+/**
+ * SubscriptionApi — `/api/v1/subscription`.
+ *
+ * Single-read surface: the caller's current account/credit state. Idapt is
+ * pay-as-you-go — there are no subscription plans, periods, or trials. The
+ * payload carries the account tier (`plan` = `free` / `paid`, `is_paid`), the
+ * credit `balance` (USD), and the auto top-up settings.
+ *
+ * Anonymous / unauthenticated callers receive the `free` view rather than a
+ * 401 — the route deliberately mirrors the cookie-route behaviour so CLI/SDK
+ * users that haven't signed up still get a usable answer.
+ *
+ * Internal correlation ids and implementation-detail fields are dropped at
+ * the route boundary; they never appear on the v1 wire.
+ */
+
+declare class SubscriptionApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    get(opts?: CallOptions): Promise<Subscription>;
+}
+
+/**
+ * TablesApi — `/api/v1/tables` (Idapt Tables, structured documents).
+ *
+ * Collections hold a field schema; records are JSON documents queried via the
+ * safe DSL. Surfaced as `client.tables.*` on `IdaptClient`.
+ */
+
+interface TableField {
+    key: string;
+    name: string;
+    type: string;
+    options?: unknown[];
+    required?: boolean;
+    default?: unknown;
+}
+interface CollectionSchemaInput {
+    fields: TableField[];
+}
+interface CreateCollectionInput {
+    name: string;
+    description?: string | null;
+    icon?: string | null;
+    schema?: CollectionSchemaInput;
+    workspace_id?: string;
+}
+interface UpdateCollectionInput {
+    name?: string;
+    description?: string | null;
+    icon?: string | null;
+    schema?: CollectionSchemaInput;
+}
+interface TableQuery {
+    where?: unknown;
+    sort?: {
+        field: string;
+        dir?: "asc" | "desc";
+    }[];
+    limit?: number;
+    cursor?: string;
+}
+declare class TablesApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(opts?: CallOptions & {
+        workspaceId?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<TableCollection[]>;
+    get(id: string, opts?: CallOptions): Promise<TableCollection>;
+    create(input: CreateCollectionInput, opts?: CallOptions): Promise<TableCollection>;
+    update(id: string, input: UpdateCollectionInput, opts?: CallOptions): Promise<TableCollection>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /** Query a collection's records with the filter/sort/paginate DSL. */
+    query(id: string, query?: TableQuery, opts?: CallOptions): Promise<TableRecord[]>;
+    createRecord(id: string, values: Record<string, unknown>, opts?: CallOptions): Promise<TableRecord>;
+    getRecord(id: string, recordId: string, opts?: CallOptions): Promise<TableRecord>;
+    updateRecord(id: string, recordId: string, values: Record<string, unknown>, opts?: CallOptions): Promise<TableRecord>;
+    deleteRecord(id: string, recordId: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /** Export a collection's records as a CSV string (header row = field keys). */
+    exportCsv(id: string, opts?: CallOptions): Promise<string>;
+    /** Import records into a collection from a CSV string. Returns the count. */
+    importCsv(id: string, csv: string, opts?: CallOptions): Promise<{
+        imported: number;
+    }>;
+}
+
+/**
+ * TriggersApi — `/api/v1/triggers`.
+ *
+ * Triggers fire actions (run code, run chat) on events (webhook, schedule,
+ * manual). The `fire` endpoint is unauthenticated — it validates the
+ * per-trigger webhook secret instead of the bearer token. This SDK handles
+ * both modes: regular calls use `this.ctx.key`; `fire` can be called with
+ * an explicit secret override.
+ */
+
+interface FireTriggerInput {
+    /**
+     * Webhook secret for this trigger. Overrides the client's `ap_` key.
+     * Required when calling `fire` outside the creating user's session.
+     */
+    secret: string;
+    /** Optional context overrides forwarded to the action. */
+    body?: Record<string, unknown>;
+}
+interface ListTriggerRunsQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+}
+interface ListTriggersQuery {
+    workspace_id?: string;
+    include_archived?: boolean;
+    archived_only?: boolean;
+}
+interface BulkTriggerCostStatsQuery {
+    workspace_id?: string;
+}
+declare class TriggersApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query?: ListTriggersQuery, opts?: CallOptions): Promise<Trigger[]>;
+    /**
+     * Create a trigger. `workspace_id` is passed in the request BODY (alongside
+     * the flat trigger definition) — it is not a query param. The request
+     * body is flat: every scheduling field (`cron_expression`, …) and every
+     * action field (`agent_id`, `prompt_template`, `file_id`, …) sits at the
+     * top level — there are no nested `trigger_config` / `action_config`
+     * objects any more.
+     *
+     * For a `webhook` trigger the response additionally carries a one-time
+     * plaintext `secret` (use `TriggerWithSecret`); other trigger types
+     * resolve to a plain `Trigger`.
+     */
+    create(workspaceId: string, input: CreateTriggerInput, opts?: CallOptions): Promise<TriggerWithSecret | Trigger>;
+    get(id: string, opts?: CallOptions): Promise<Trigger>;
+    update(id: string, input: UpdateTriggerInput, opts?: CallOptions): Promise<Trigger>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    archive(id: string, opts?: CallOptions): Promise<Trigger>;
+    unarchive(id: string, opts?: CallOptions): Promise<Trigger>;
+    /**
+     * Fire a trigger via its webhook secret. This endpoint does NOT use the
+     * client's `ap_` key — the bearer is the trigger's secret — so we build a
+     * one-off HttpContext for it rather than mutating the shared one.
+     *
+     * Responds HTTP 202. The response identifies the fired trigger via `id`
+     * only.
+     */
+    fire(id: string, input: FireTriggerInput, opts?: CallOptions): Promise<{
+        id: string;
+    }>;
+    /**
+     * Rotate the webhook secret. Returns the trigger with a fresh one-time
+     * plaintext `secret` populated (`TriggerWithSecret`). The old secret
+     * immediately stops working.
+     */
+    rotateSecret(id: string, opts?: CallOptions): Promise<TriggerWithSecret>;
+    /** Recent fires + their success/error outcome. */
+    listRuns(id: string, query?: ListTriggerRunsQuery, opts?: CallOptions): Promise<TriggerRun[]>;
+    getCostStats(id: string, opts?: CallOptions): Promise<TriggerCostStats>;
+    getCostStatsMap(query?: BulkTriggerCostStatsQuery, opts?: CallOptions): Promise<Record<string, TriggerCostStats>>;
+}
+
+/**
+ * UserApi — identity + usage.
+ *
+ * `me()` is always callable (implicit `user:read` grant). `usage()` may
+ * require elevated permissions depending on deployment — check the
+ * manifest if you get a 403.
+ */
+
+interface ListUsageHistoryQuery {
+    limit?: number;
+    /** Opaque pagination cursor — echo `pagination.next_cursor`. */
+    cursor?: string;
+    /** Filter history by call type (e.g. "chat", "image"). */
+    call_type?: string;
+}
+declare class UserApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /** Current authenticated user's profile. */
+    me(opts?: CallOptions): Promise<User>;
+    /**
+     * Storage usage summary — bytes used / total, snapshot footprint.
+     * Corresponds to `GET /me/usage?view=summary` (the default).
+     */
+    usage(opts?: CallOptions): Promise<UsageSummary>;
+    /**
+     * Paginated history of LLM / image / audio calls + cost.
+     * Corresponds to `GET /me/usage?view=history`.
+     */
+    usageHistory(query?: ListUsageHistoryQuery, opts?: CallOptions): Promise<UsageRecord[]>;
+}
+
+/**
+ * WebSearchApi — `POST /api/v1/web/search`.
+ *
+ * External web search. Needs the elevated `web:search` permission. Apps
+ * that want this must declare it in their manifest; `client.escalate()`
+ * can request it at runtime.
+ */
+
+interface WebSearchInput {
+    query: string;
+    /** Min 1, max 25. Default 12. */
+    num_results?: number;
+}
+declare class WebSearchApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    search(input: WebSearchInput, opts?: CallOptions): Promise<WebSearchResponse>;
+}
+
+/**
+ * WorkspacesApi — `/api/v1/workspaces` CRUD + members + invitations.
+ *
+ * Members, invitations, and secrets all live as sub-resources under
+ * `/workspaces/:id/...`. Members and invitations are exposed as flat methods
+ * on this class to avoid an extra factory step. Workspace secrets are a
+ * heavier surface and get their own top-level module (`client.secrets`).
+ */
+
+interface CreateWorkspaceInput {
+    name: string;
+    slug: string;
+    description?: string;
+    icon?: string;
+}
+interface UpdateWorkspaceInput {
+    name?: string;
+    description?: string | null;
+    icon?: string | null;
+    /**
+     * New workspace slug. Follows the canonical workspace-slug rules; the route
+     * dispatches a slug change through its rename pipeline server-side.
+     */
+    slug?: string;
+}
+interface ListWorkspacesQuery {
+    include_archived?: boolean;
+    archived_only?: boolean;
+}
+/** Only non-owner roles are acceptable in member write paths. */
+type WritableMemberRole = Extract<WorkspaceMemberRole, "admin" | "editor" | "viewer">;
+interface AddMemberInput {
+    actor_id: string;
+    role: WritableMemberRole;
+}
+interface UpdateMemberInput {
+    role: WritableMemberRole;
+}
+interface CreateInvitationInput {
+    /** Invitee profile slug, e.g. `alice`. */
+    slug: string;
+    role?: WritableMemberRole;
+}
+/**
+ * Result of `POST /v1/workspaces/{id}/invitations`. The v1 contract keys an
+ * invitation by `invitee_slug` — there is no `invitationId` / `id` field.
+ */
+interface CreateInvitationResult {
+    invitee_slug: string;
+    role: WritableMemberRole;
+    status: string;
+}
+/** Result of `DELETE /v1/workspaces/{id}/invitations?invitee_slug=…`. */
+interface DeleteInvitationResult {
+    deleted: true;
+    /** The workspace id the invitation was removed from. */
+    id: string;
+}
+declare class WorkspacesApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    list(query?: ListWorkspacesQuery, opts?: CallOptions): Promise<Workspace[]>;
+    create(input: CreateWorkspaceInput, opts?: CallOptions): Promise<Workspace>;
+    get(id: string, opts?: CallOptions): Promise<Workspace>;
+    update(id: string, input: UpdateWorkspaceInput, opts?: CallOptions): Promise<Workspace>;
+    delete(id: string, opts?: CallOptions): Promise<DeletedResponse>;
+    archive(id: string, opts?: CallOptions): Promise<Workspace>;
+    unarchive(id: string, opts?: CallOptions): Promise<Workspace>;
+    listMembers(id: string, opts?: CallOptions): Promise<WorkspaceMember[]>;
+    addMember(id: string, input: AddMemberInput, opts?: CallOptions): Promise<WorkspaceMember>;
+    updateMember(id: string, memberId: string, input: UpdateMemberInput, opts?: CallOptions): Promise<WorkspaceMember>;
+    removeMember(id: string, memberId: string, opts?: CallOptions): Promise<DeletedResponse>;
+    listInvitations(id: string, opts?: CallOptions): Promise<WorkspaceInvitation[]>;
+    /**
+     * Invite an existing idapt user by their profile slug. Idempotent on
+     * the `(workspace_id, slug)` pair — reissue safely. Personal workspaces
+     * reject invitations.
+     */
+    createInvitation(id: string, input: CreateInvitationInput, opts?: CallOptions): Promise<CreateInvitationResult>;
+    /**
+     * Revoke a pending invitation. The invitation is identified by the
+     * invitee's profile slug, passed as the `invitee_slug` query param —
+     * there is no invitation id. Returns `{ deleted: true, id }` where `id`
+     * is the workspace id (top-level, not enveloped under `data`).
+     */
+    deleteInvitation(id: string, inviteeSlug: string, opts?: CallOptions): Promise<DeleteInvitationResult>;
+}
+
+/**
+ * IdaptClient — the object consumers hold after `connect()`.
+ *
+ * Wires the folder accessors, user API, and auth escalation into one cohesive
+ * surface. Deliberately thin — the heavy lifting is in the individual modules
+ * so each can be tested in isolation.
+ *
+ * The client is **always remote** — it talks to the Idapt backend, either via
+ * the cookie/bootstrap flow (hosted on an app subdomain) or library bearer
+ * mode. Browser apps are **npm-only**: there is no off-Idapt local mode and no
+ * IndexedDB / relative-fetch degradation. Every surface always works.
+ */
+
+interface IdaptClientDeps {
+    credential: StoredCredential;
+    browserAppDomain: string;
+    fetch?: typeof fetch;
+    /** Inject for tests. Defaults to `window.location.assign(url)`. */
+    navigate?: (url: string) => void;
+}
+declare class IdaptClient {
+    /** The app's own code/bundle (read-only). */
+    readonly app: AppFolder;
+    /** The per-(user × app) data KV (read-write), scoped by the app resource id. */
+    readonly data: DataFolder;
+    /** Identity + usage. */
+    readonly user: UserApi;
+    /** Raw file ops by id (upload, move, run, folders). */
+    readonly files: FilesApi;
+    /** Agents CRUD. */
+    readonly agents: AgentsApi;
+    /** Chats CRUD + messages / runs / cost. */
+    readonly chats: ChatsApi;
+    /** Workspaces CRUD + members + invitations + fork. */
+    readonly workspaces: WorkspacesApi;
+    /** Triggers CRUD + fire, rotate-secret, runs. */
+    readonly triggers: TriggersApi;
+    /** Computers CRUD + lifecycle + exec/tmux/sftp + ports + users + env + pair. */
+    readonly computers: ComputersApi;
+    /** Workspace secrets CRUD. */
+    readonly secrets: SecretsApi;
+    /** Datastore (KV) — workspace key/value store for app + agent state. */
+    readonly kv: DatastoreApi;
+    /** Blobs — workspace object store for large / binary data. */
+    readonly blobs: BlobsApi;
+    /** Idapt Tables — structured document collections + records + query. */
+    readonly tables: TablesApi;
+    /** Realtime — broadcast + presence + live SSE subscribe over channels. */
+    readonly realtime: RealtimeApi;
+    /** User-API-key CRUD (`uk_` keys). Header-auth (API-key transport) is rejected. */
+    readonly apiKeys: ApiKeysApi;
+    /** Notifications: per-row verbs, bulk readAll, send, config + preferences. */
+    readonly notifications: NotificationsApi;
+    /** Account preferences (display name, slug, public visibility, consents). */
+    readonly settings: SettingsApi;
+    /** Current subscription view (plan, status, period, trial, downgrade target). */
+    readonly subscription: SubscriptionApi;
+    /** Resource shares + the inverse `/shared-with-me` list. */
+    readonly sharing: SharingApi;
+    /** Hub / store: search community items + install into a workspace. */
+    readonly store: StoreApi;
+    /** LLM model catalogue. */
+    readonly models: ModelsApi;
+    /** User-owned BYOK and daemon-local model provider endpoints. */
+    readonly providerEndpoints: ProviderEndpointsApi;
+    /** Image models + generation. */
+    readonly images: ImagesApi;
+    /** Text-to-speech + transcription. */
+    readonly audio: AudioApi;
+    /** Execute code files in sandboxed Lambda. */
+    readonly code: CodeRunsApi;
+    /** Full-text search across user content. */
+    readonly search: SearchApi;
+    /** External web search. */
+    readonly web: WebSearchApi;
+    /** Fetch the SKILL.md instruction text. */
+    readonly guide: GuideApi;
+    /** OpenAPI 3.1 spec retrieval. */
+    readonly docs: DocsApi;
+    /** Browser-app client metadata (appId, folder ids, api url, mode). */
+    readonly meta: ClientMeta;
+    /** Which backing the client is wired against (always `"remote"`). */
+    readonly mode: RuntimeMode;
+    private readonly deps;
+    /** HTTP context for server calls. */
+    private readonly ctx;
+    constructor(deps: IdaptClientDeps);
+    /**
+     * The `ap_`/`uk_` key — use only for raw v1 calls the SDK doesn't wrap.
+     * In cookie mode there is no raw key — it lives only in the httpOnly app-key
+     * cookie the browser attaches automatically — so this throws; use the SDK
+     * surfaces (or `getAuthToken()` for ad-hoc bearer use) instead.
+     */
+    getApiKey(): string;
+    /** API base URL the client targets. */
+    getApiUrl(): string;
+    /**
+     * Mint a short-lived JWT for ad-hoc Bearer use (custom fetch calls,
+     * third-party libraries, WebSocket protocols). Expires after ~15 min —
+     * cache in memory, never persist to localStorage.
+     *
+     * Two mint paths depending on auth mode:
+     *   - **bearer/library** — the raw `uk_`/`ap_` key authenticates better-auth's
+     *     `/api/auth/token` directly.
+     *   - **cookie** — the iframe carries only the httpOnly `__Secure-idapt_app_key`
+     *     cookie, which better-auth's session-based `/api/auth/token` can't see.
+     *     We mint via `/api/browser-app/token` instead (resolves the app principal
+     *     from that cookie). The request rides `credentials: "include"` and sends
+     *     NO empty `Bearer` header.
+     */
+    getAuthToken(): Promise<string>;
+    /**
+     * Low-level mint against `/api/browser-app/token` — exchanges the httpOnly
+     * app cookie for a short-lived `idapt-api` JWT. Used by the cookie-mode v1
+     * surfaces' token provider AND by `getAuthToken()` in cookie mode.
+     *
+     * Carries the app cookie via `credentials: "include"`; sends `Sec-Fetch-Site:
+     * same-origin` so the server's CSRF guard accepts it (the SDK only ever runs
+     * same-origin under the app subdomain in cookie mode).
+     */
+    private fetchAppToken;
+    /**
+     * Build a lazily-minting, self-refreshing app-token provider for the
+     * cookie-mode v1 contexts. Caches the JWT until ~30 s before its stated
+     * expiry; `invalidate()` (wired to the request layer's 401 hook) drops the
+     * cache so the next call re-mints.
+     */
+    private makeAppTokenMinter;
+    /**
+     * Request additional scopes at runtime. Navigates to the consent page;
+     * the returned promise never resolves because the page is navigating away.
+     *
+     * The credential doesn't change — principal.authorization is broadened
+     * server-side. When the user lands back in the app, the cached key now
+     * has the new scope.
+     */
+    escalate(permissions: EscalateRequest): Promise<never>;
+    /**
+     * No-op in the cookie-based flow — the `__idapt_app_key` cookie is
+     * httpOnly + server-managed, so the SDK can't clear it from JS. To end a
+     * hosted session, revoke the credential from the main-app Connected Apps
+     * settings.
+     */
+    disconnect(): void;
+    private navigate;
+}
+
+export { type ListRunsQuery as $, type AddMemberInput as A, type BlobMeta as B, COMMAND_BINDINGS as C, DatastoreApi as D, type DeleteInvitationResult as E, type DeletedResult as F, DocsApi as G, type ExecCommandInput as H, IdaptClient as I, type ExecuteCommandOptions as J, FilesApi as K, type FireTriggerInput as L, type GenerateImageInput as M, GuideApi as N, type GuideContent as O, type IdaptClientDeps as P, ImagesApi as Q, type InstallStoreItemInput as R, type ListAgentsQuery as S, type ListApiKeysQuery as T, type ListChatsQuery as U, type ListComputersQuery as V, type ListExecutionsQuery as W, type ListFilesQuery as X, type ListMessagesQuery as Y, type ListNotificationsQuery as Z, type ListResult as _, AgentsApi as a, type V1CommandName as a$, type ListSharedWithMeQuery as a0, type ListSharesQuery as a1, type ListTriggerRunsQuery as a2, type ListUsageHistoryQuery as a3, ModelsApi as a4, type NotificationAudience as a5, type NotificationPreferenceUpdate as a6, NotificationsApi as a7, type PairComputerInput as a8, type PairComputerResult as a9, SharingApi as aA, type SpeakInput as aB, type SseEvent as aC, StoreApi as aD, type SubscribeOptions as aE, SubscriptionApi as aF, type TableQuery as aG, TablesApi as aH, type TmuxInput as aI, type TmuxOp as aJ, type TranscribeInput as aK, TriggersApi as aL, type UpdateAgentInput as aM, type UpdateApiKeyInput as aN, type UpdateChatInput as aO, type UpdateCollectionInput as aP, type UpdateComputerInput as aQ, type UpdateComputerUserInput as aR, type UpdateMemberInput as aS, type UpdateNotificationInput as aT, type UpdateProviderEndpointInput as aU, type UpdateSecretInput as aV, type UpdateSettingsInput as aW, type UpdateShareInput as aX, type UpdateWorkspaceInput as aY, type UploadInput as aZ, UserApi as a_, type PatchFileInput as aa, type PatchPortInput as ab, type PresenceEntry as ac, type PresenceHeartbeatOptions as ad, type ProviderEndpointModelMappingInput as ae, ProviderEndpointsApi as af, RealtimeApi as ag, type RealtimeEvent as ah, type RemoveShareInput as ai, type RepromptMessageInput as aj, type RotateApiKeyInput as ak, type RotateApiKeyResult as al, type RunCodeInput as am, type RunFileInput as an, SearchApi as ao, type SearchInput as ap, type SearchStoreQuery as aq, SecretsApi as ar, type SendMessageInput as as, type SendNotificationInput as at, type SendNotificationResult as au, SettingsApi as av, type SftpInput as aw, type SftpListResult as ax, type SftpOp as ay, type SftpUploadInput as az, ApiKeysApi as b, WebSearchApi as b0, type WebSearchInput as b1, WorkspacesApi as b2, type WritableMemberRole as b3, awaitOperation as b4, executeCommand as b5, getFileBlob as b6, getFileText as b7, listFiles as b8, AudioApi as c, BlobsApi as d, type BlobsListOptions as e, type ChannelHandle as f, ChatsApi as g, CodeRunsApi as h, type CommandBinding as i, ComputersApi as j, type CreateAgentInput as k, type CreateApiKeyInput as l, type CreateChatInput as m, type CreateCollectionInput as n, type CreateComputerInput as o, type CreateComputerUserInput as p, type CreateFolderInput as q, type CreateInvitationInput as r, type CreateInvitationResult as s, type CreateProviderEndpointInput as t, type CreateSecretInput as u, type CreateShareInput as v, type CreateUserEnvVarInput as w, type CreateWorkspaceInput as x, type DatastoreListOptions as y, type DatastoreSetOptions as z };