@idapt/browser-app-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,372 @@
+import { I as IdaptClient } from './client-CO-P-xYI.cjs';
+export { A as AddMemberInput, a as AgentsApi, b as ApiKeysApi, c as AudioApi, B as BlobMeta, d as BlobsApi, e as BlobsListOptions, C as COMMAND_BINDINGS, f as ChannelHandle, g as ChatsApi, h as CodeRunsApi, i as CommandBinding, j as ComputersApi, k as CreateAgentInput, l as CreateApiKeyInput, m as CreateChatInput, n as CreateCollectionInput, o as CreateComputerInput, p as CreateComputerUserInput, q as CreateFolderInput, r as CreateInvitationInput, s as CreateInvitationResult, t as CreateProviderEndpointInput, u as CreateSecretInput, v as CreateShareInput, w as CreateUserEnvVarInput, x as CreateWorkspaceInput, D as DatastoreApi, y as DatastoreListOptions, z as DatastoreSetOptions, E as DeleteInvitationResult, F as DeletedResult, G as DocsApi, H as ExecCommandInput, J as ExecuteCommandOptions, K as FilesApi, L as FireTriggerInput, M as GenerateImageInput, N as GuideApi, O as GuideContent, P as IdaptClientDeps, Q as ImagesApi, R as InstallStoreItemInput, S as ListAgentsQuery, T as ListApiKeysQuery, U as ListChatsQuery, V as ListComputersQuery, W as ListExecutionsQuery, X as ListFilesQuery, Y as ListMessagesQuery, Z as ListNotificationsQuery, _ as ListResult, $ as ListRunsQuery, a0 as ListSharedWithMeQuery, a1 as ListSharesQuery, a2 as ListTriggerRunsQuery, a3 as ListUsageHistoryQuery, a4 as ModelsApi, a5 as NotificationAudience, a6 as NotificationPreferenceUpdate, a7 as NotificationsApi, a8 as PairComputerInput, a9 as PairComputerResult, aa as PatchFileInput, ab as PatchPortInput, ac as PresenceEntry, ad as PresenceHeartbeatOptions, ae as ProviderEndpointModelMappingInput, af as ProviderEndpointsApi, ag as RealtimeApi, ah as RealtimeEvent, ai as RemoveShareInput, aj as RepromptMessageInput, ak as RotateApiKeyInput, al as RotateApiKeyResult, am as RunCodeInput, an as RunFileInput, ao as SearchApi, ap as SearchInput, aq as SearchStoreQuery, ar as SecretsApi, as as SendMessageInput, at as SendNotificationInput, au as SendNotificationResult, av as SettingsApi, aw as SftpInput, ax as SftpListResult, ay as SftpOp, az as SftpUploadInput, aA as SharingApi, aB as SpeakInput, aC as SseEvent, aD as StoreApi, aE as SubscribeOptions, aF as SubscriptionApi, aG as TableQuery, aH as TablesApi, aI as TmuxInput, aJ as TmuxOp, aK as TranscribeInput, aL as TriggersApi, aM as UpdateAgentInput, aN as UpdateApiKeyInput, aO as UpdateChatInput, aP as UpdateCollectionInput, aQ as UpdateComputerInput, aR as UpdateComputerUserInput, aS as UpdateMemberInput, aT as UpdateNotificationInput, aU as UpdateProviderEndpointInput, aV as UpdateSecretInput, aW as UpdateSettingsInput, aX as UpdateShareInput, aY as UpdateWorkspaceInput, aZ as UploadInput, a_ as UserApi, a$ as V1CommandName, b0 as WebSearchApi, b1 as WebSearchInput, b2 as WorkspacesApi, b3 as WritableMemberRole, b4 as awaitOperation, b5 as executeCommand, b6 as getFileBlob, b7 as getFileText, b8 as listFiles } from './client-CO-P-xYI.cjs';
+import { H as HttpContext, C as CallOptions, A as AiGatewayProvider, a as AiGatewayUsageRow, D as DataStore, F as File, W as WriteOptions, b as DeletedResponse, c as DataStoreUploadInput, d as FileUploadResult, e as DataStoreCreateFolderInput, f as ConnectOptions } from './data-Chus9wn2.cjs';
+export { g as Agent, h as AgentRun, i as AgentRunState, j as ApiKey, k as AppFolder, l as AudioModel, m as AudioModelCapabilities, n as AudioModelPricing, o as AuthMode, B as BlobObject, p as BundleReader, q as Chat, r as ChatCost, s as ChatCostByCallType, t as ChatStopResult, u as ClientMeta, v as Computer, w as ComputerEnvVar, x as ComputerExecResult, y as ComputerLoggingLevel, z as ComputerPort, E as ComputerServerInfo, G as ComputerState, I as ComputerType, J as ComputerUser, K as CreateTriggerInput, L as DataCreateFolderInput, M as DataFolder, N as DataUploadInput, O as DatastoreEntry, P as EscalateRequest, Q as ExecutionBackend, R as ExecutionRun, S as ExecutionRunStatus, T as FileList, U as HttpRequest, V as ImageGenerationResult, X as ImageModel, Y as ImageModelPricing, Z as LLMModel, _ as LLMModelCapabilities, $ as LLMModelPricing, a0 as ListEnvelope, a1 as ManagedProviderPreset, a2 as Message, a3 as MessageCostEntry, a4 as MessageCosts, a5 as ModelBase, a6 as ModelModality, a7 as Notification, a8 as NotificationConfig, a9 as NotificationPreference, aa as NotificationSenderKind, ab as Pagination, ac as Permission, ad as ProviderEndpoint, ae as ProviderEndpointConnectionType, af as ProviderEndpointKind, ag as ProviderEndpointModality, ah as ProviderEndpointModelMapping, ai as ProviderEndpointProtocol, aj as ProviderEndpointProviderKey, ak as ProviderEndpointRuntime, al as ProviderEndpointTestResult, am as ProviderEndpointTransport, an as ProviderEndpointVisibility, ao as QueryInput, ap as RemoteBundleReader, aq as RepromptResult, ar as RunCostMetrics, as as RuntimeMode, at as SearchResult, au as Secret, av as SecretWithValue, aw as SendMessageResult, ax as Settings, ay as SftpEntry, az as Share, aA as ShareDeletedResult, aB as SharePermission, aC as ShareResourceType, aD as SharedWithMeItem, aE as SingleEnvelope, aF as SpeechResult, aG as SpeechStreamEvent, aH as StoreInstallResult, aI as StoreItem, aJ as StoreItemType, aK as StoredCredential, aL as Subscription, aM as SubscriptionPlan, aN as TableCollection, aO as TableRecord, aP as TmuxWindow, aQ as TranscriptionResult, aR as TranscriptionStreamEvent, aS as Trigger, aT as TriggerActionType, aU as TriggerCostStats, aV as TriggerRun, aW as TriggerType, aX as TriggerWithSecret, aY as TtsVoice, aZ as TtsVoiceGender, a_ as UpdateTriggerInput, a$ as UsageRecord, b0 as UsageSummary, b1 as User, b2 as WebSearchHit, b3 as WebSearchResponse, b4 as Workspace, b5 as WorkspaceInvitation, b6 as WorkspaceMember, b7 as WorkspaceMemberRole, b8 as buildUrl, b9 as request, ba as requestRaw } from './data-Chus9wn2.cjs';
+import 'zod';
+
+/**
+ * AiGatewayApi — `/api/v1/ai-gateway`.
+ *
+ * The Idapt AI Gateway routing read surface: the routable provider catalog and
+ * the per-model / per-provider usage breakdown. (BYOK provider endpoints are
+ * `client.providerEndpoints`; routing PREFERENCES are managed in-app.)
+ */
+
+interface AiGatewayProvidersOptions extends CallOptions {
+    /** Restrict to providers that serve this idapt model id (author/model). */
+    modelId?: string;
+}
+interface AiGatewayUsageOptions extends CallOptions {
+    /** Grouping — `model` (default) or `provider`. */
+    view?: "model" | "provider";
+    /** Public workspace id — defaults to the caller's personal workspace. */
+    workspaceId?: string;
+    /** Look-back window in days (1–365, default 30). */
+    windowDays?: number;
+}
+declare class AiGatewayApi {
+    private readonly ctx;
+    constructor(ctx: HttpContext);
+    /** List the routable serving providers (optionally for one model). */
+    providers(opts?: AiGatewayProvidersOptions): Promise<AiGatewayProvider[]>;
+    /** Per-model / per-provider usage breakdown over a window. */
+    usage(opts?: AiGatewayUsageOptions): Promise<AiGatewayUsageRow[]>;
+}
+
+/**
+ * IdaptClient — the generic, isomorphic Idapt v1 API client.
+ *
+ * Holds one typed surface per v1 resource, all wired against a single bearer
+ * {@link HttpContext}. This is the polyglot-generatable core of the SDK: it has
+ * NO browser-app runtime (cookie bootstrap, app-data KV, React hooks) — that
+ * lives in `@idapt/browser-app-sdk`, which composes this client.
+ *
+ * Construct it via {@link connect} (`connect({ apiUrl, key })`) rather than
+ * directly.
+ */
+
+interface IdaptClientOptions {
+    /** API origin, e.g. `https://idapt.app`. */
+    apiUrl: string;
+    /** Bearer credential (`uk_` / `pk_` / `ap_`). */
+    key: string;
+    /** Custom fetch (tests / polyfills). Defaults to `globalThis.fetch`. */
+    fetch?: typeof fetch;
+}
+
+/**
+ * Typed error hierarchy for @idapt/sdk.
+ *
+ * Every API-originated failure is surfaced as an `IdaptError` or a subclass.
+ * Consumers can branch on `error.code` (stable string) or `instanceof`
+ * (preferred in TypeScript). The raw HTTP status is preserved on `.status`.
+ *
+ * Why a class hierarchy (not just codes)?
+ *   - `catch (err) { if (err instanceof AuthError) ... }` reads cleanly
+ *   - Each subclass has a `.name` that matches its constructor, so stack
+ *     traces and devtools show the right label
+ *   - Adding a subclass is a non-breaking change
+ *
+ * ## Wire error envelope — `{ error: { type, message, code? } }`
+ *
+ * The v1 error envelope splits its old flat `code` field into two:
+ *   - **`type`** — the coarse category (`invalid_request`, `unauthorized`,
+ *     `forbidden`, `not_found`, `conflict`, `rate_limit`,
+ *     `service_unavailable`, `internal_error`). This is what clients branch
+ *     on for coarse handling — the SDK mirrors it onto `IdaptError.type`.
+ *   - **`code`** — an OPTIONAL finer computer-branchable sub-code carried
+ *     alongside `type`, present only on specific errors (today the only
+ *     value is `model_not_available_for_tier`). The SDK surfaces it as
+ *     `IdaptError.subCode`. A client that does not recognise a sub-code
+ *     falls back to `type`, so new sub-codes are never breaking.
+ *
+ * Note: `IdaptError.code` is the SDK's own stable discriminant (it predates
+ * the wire split and pairs 1:1 with the `instanceof` subclasses). The wire
+ * `error.type` lands on `.type`; the wire `error.code` lands on `.subCode`.
+ */
+/**
+ * SDK-internal stable error discriminant. Pairs 1:1 with the `instanceof`
+ * subclasses. This is NOT the wire `error.type` — see `IdaptErrorType` for
+ * that — it is the SDK's own long-stable code (kept for back-compat).
+ */
+type IdaptErrorCode = "network_error" | "auth_expired" | "auth_missing" | "permission_denied" | "not_found" | "conflict" | "rate_limited" | "invalid_request" | "service_unavailable" | "server_error" | "unknown";
+/**
+ * The wire `error.type` enum — the coarse category the v1 API stamps on
+ * every error envelope. Mirrored onto `IdaptError.type` verbatim.
+ */
+type IdaptErrorType = "invalid_request" | "unauthorized" | "forbidden" | "not_found" | "conflict" | "rate_limit" | "service_unavailable" | "internal_error";
+/**
+ * The wire `error.code` finer sub-code enum. Optional — present only on
+ * specific errors. Typed as a union with `string` so an unrecognised
+ * future sub-code still type-checks (consumers fall back to `.type`).
+ */
+type IdaptErrorSubCode = "model_not_available_for_tier" | (string & {});
+interface IdaptErrorInit {
+    message: string;
+    code: IdaptErrorCode;
+    status?: number;
+    body?: unknown;
+    cause?: unknown;
+    /** Wire `error.type` — the coarse category. */
+    type?: IdaptErrorType;
+    /** Wire `error.code` — the optional finer sub-code. */
+    subCode?: IdaptErrorSubCode;
+}
+declare class IdaptError extends Error {
+    /** SDK-internal stable discriminant (back-compat; pairs with subclasses). */
+    readonly code: IdaptErrorCode;
+    /** Wire `error.type` — the coarse category the server reported. */
+    readonly type?: IdaptErrorType;
+    /**
+     * Wire `error.code` — the optional finer sub-code, present only on
+     * specific errors (e.g. `model_not_available_for_tier`). Branch on this
+     * for fine-grained handling and fall back to `type` / the subclass when
+     * it is absent or unrecognised.
+     */
+    readonly subCode?: IdaptErrorSubCode;
+    readonly status: number;
+    readonly body: unknown;
+    constructor(init: IdaptErrorInit);
+}
+declare class NetworkError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code"> & {
+        code?: "network_error";
+    });
+}
+declare class AuthError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code"> & {
+        code?: "auth_expired" | "auth_missing";
+    });
+}
+declare class PermissionError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code">);
+}
+declare class NotFoundError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code">);
+}
+declare class ConflictError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code">);
+}
+declare class RateLimitError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code"> & {
+        retryAfter?: number;
+    });
+    readonly retryAfter?: number;
+}
+declare class InvalidRequestError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code">);
+}
+/**
+ * HTTP 503 — an upstream dependency the request needed (a computer daemon,
+ * an inference provider) was unreachable. The request itself was valid, so
+ * this is **retryable**: `retryable` is always `true` and `retryAfter`
+ * carries the server's `retry_after` hint when one is present.
+ *
+ * Returned by the computer `exec` / `tmux` / `sftp` endpoints and
+ * `POST /v1/audio/transcriptions`.
+ */
+declare class ServiceUnavailableError extends IdaptError {
+    /** Always `true` — a 503 means "retry later", the request was fine. */
+    readonly retryable = true;
+    /** Server-suggested seconds to wait before retrying, when provided. */
+    readonly retryAfter?: number;
+    constructor(init: Omit<IdaptErrorInit, "code"> & {
+        retryAfter?: number;
+    });
+}
+declare class ServerError extends IdaptError {
+    constructor(init: Omit<IdaptErrorInit, "code">);
+}
+/**
+ * Map an HTTP response status code to the correct error subclass.
+ * Centralised so the mapping stays consistent across every SDK call site.
+ *
+ * The v1 contract pins each failure mode to a specific status:
+ *   - `invalid_request`     → always HTTP 422 (validation failures)
+ *   - `not_found`           → always HTTP 404 (missing resource)
+ *   - `permission_denied`   → 403, `auth_*` → 401, `conflict` → 409,
+ *     `rate_limited`        → 429
+ *   - `service_unavailable` → 503 (upstream dependency down — retryable)
+ *   - `server_error`        → any other 5xx (500, 502, …)
+ * Any other 4xx the server emits is unmapped and surfaces as the
+ * `IdaptError` base with code `unknown` — we do NOT label a bare 400 as
+ * `invalid_request`, since that code is reserved for 422.
+ *
+ * `type` / `subCode` are the wire `error.type` / `error.code` lifted off
+ * the response envelope by `extractErrorFields`; they ride along so
+ * consumers can branch on the fine-grained sub-code.
+ */
+declare function errorFromStatus(status: number, message: string, body: unknown): IdaptError;
+
+declare const VERSION: string;
+
+/**
+ * Remote `DataStore` — the Idapt-backend-backed implementation of the
+ * read-write data surface used by {@link DataFolder}.
+ *
+ * It backs onto the dedicated **per-(user × app) app-data KV** at
+ * `/api/browser-app/data/{appResId}/{key}` — NOT Drive. Each entry is a
+ * `browser_app_data` row keyed `(browserAppId, principalId, key)` and is
+ * authenticated by the app's `ap_` credential (carried as the Bearer on the
+ * SDK's {@link HttpContext}). This is the DB-first replacement for the old
+ * `.app-data/{appResId}/` Drive folder, which no longer exists.
+ *
+ * ## Key model — the KV key IS the file name
+ *
+ * The KV has no notion of file *ids* separate from *names*: there is one flat
+ * namespace of string keys per principal. `DataFolder` is written against a
+ * Drive-ish `{id, name}` `File` shape, so this adapter collapses the two: for
+ * every entry **`id === name === key`**. `DataFolder`'s name-cache and
+ * name-based API (`set`/`get`/`has`/`setJSON`/`getJSON`/`remove`) therefore
+ * resolve a name straight to its key with no id indirection.
+ *
+ * ## Wire mapping
+ *
+ * | `DataStore` method | HTTP                                          | Notes |
+ * |--------------------|-----------------------------------------------|-------|
+ * | `read(key)`        | `GET    /api/browser-app/data/{app}/{key}`    | returns the stored string (`{value}` body, or raw blob text) |
+ * | `write(key, s)`    | `PUT    /api/browser-app/data/{app}/{key}` `{value: s}` | |
+ * | `delete(key)`      | `DELETE /api/browser-app/data/{app}/{key}`    | idempotent |
+ * | `list()`           | `GET    /api/browser-app/data/{app}/`         | principal's keys → `File[]` (id=name=key) |
+ * | `getMetadata(key)` | `GET    /api/browser-app/data/{app}/{key}`    | 404 → `NotFoundError` |
+ * | `readBlob(key)`    | `GET    /api/browser-app/data/{app}/{key}`    | bytes as `Blob` |
+ * | `upload({file,name})` | `PUT /api/browser-app/data/{app}/{name}` `{value: <text>}` | the `set()`/`setJSON()` create path; stores the blob's **text** |
+ *
+ * ## Unsupported surfaces
+ *
+ * The KV is flat — there are no folders and no separate-id move. `createFolder`,
+ * `move`, and `listFolder(parentId)` have no KV analogue and throw a typed
+ * {@link InvalidRequestError} (`code: "invalid_request"`). `DataFolder`'s
+ * name-based API never reaches them; only an app calling the raw folder methods
+ * does, and it gets a clear, branchable error.
+ */
+
+declare class RemoteDataStore implements DataStore {
+    private readonly ctx;
+    readonly id: string;
+    /**
+     * @param ctx  HTTP context (carries the app's `ap_` bearer + api origin).
+     * @param id   The app's **resource id** (the `{appResId}` path segment) — this
+     *             is the boot's `appResourceId`, NOT a Drive folder id.
+     */
+    constructor(ctx: HttpContext, id: string);
+    /** Idapt origin this store talks to — surfaced by `DataFolder` for tooling. */
+    get apiUrl(): string;
+    /** URL-encode a single key segment for the `{...key}` catch-all route. */
+    private keyPath;
+    /** List the principal's keys for this app → `File[]` with `id = name = key`. */
+    list(opts?: CallOptions): Promise<File[]>;
+    /**
+     * No KV analogue — the app-data KV is a flat per-principal namespace with no
+     * subfolders. Throws so apps that try to enumerate a folder get a clear error.
+     */
+    listFolder(_parentId: string, _opts?: CallOptions): Promise<File[]>;
+    /** Metadata for one key — GET it; 404 surfaces as `NotFoundError`. */
+    getMetadata(key: string, opts?: CallOptions): Promise<File>;
+    /** Read a key's stored string. Inline JSON → `{value}`; blob → raw text. */
+    read(key: string, opts?: CallOptions): Promise<string>;
+    /** Read a key's raw bytes as a Blob (handles blob-backed binary entries). */
+    readBlob(key: string, opts?: CallOptions): Promise<Blob>;
+    /** Upsert a key's value. `content` is stored verbatim as `{value: content}`. */
+    write(key: string, content: string, opts?: WriteOptions): Promise<File>;
+    /** Delete a key (idempotent — DELETE on a missing key still resolves). */
+    delete(key: string, opts?: CallOptions): Promise<DeletedResponse>;
+    /**
+     * Store a blob under `name` (the KV key). This is the create path behind
+     * `DataFolder.set()` / `setJSON()`, which always upload a `text/plain` blob —
+     * we read the blob as **text** and PUT it as the key's `{value}`. Binary
+     * blobs are stored as their UTF-8 text (the KV PUT route is JSON-only); use
+     * `set()`/`setJSON()` for structured data.
+     */
+    upload(input: DataStoreUploadInput, opts?: CallOptions): Promise<FileUploadResult>;
+    /** No KV analogue — the namespace is flat. */
+    createFolder(_input: DataStoreCreateFolderInput, _opts?: CallOptions): Promise<File>;
+    /** No KV analogue — there are no folders to move between. */
+    move(_key: string, _parentId: string | null, _opts?: CallOptions): Promise<File>;
+}
+
+/**
+ * connect() — the browser-app bootstrap. Browser apps are **npm-only** and
+ * always run on Idapt; there is no off-Idapt local mode. Two modes:
+ *
+ *   1. **Library (explicit key)** — `connect({ apiUrl, key })`. Skips the
+ *      cookie dance and talks to `apiUrl` with the key as Bearer. `remote`.
+ *   2. **Hosted (cookie/bootstrap)** — the default on an Idapt app subdomain:
+ *        - `/__idapt__/init` plants an HttpOnly `__idapt_app_key` cookie on
+ *          this subdomain at iframe mount time.
+ *        - `/__idapt__/bootstrap` returns the SDK's runtime context (DB-first
+ *          `BrowserAppBootstrap`: `appResourceId`, `appId`, granted
+ *          permissions, entrypoint). There is NO raw key and NO Drive folder
+ *          ids — auth is the httpOnly cookie, which the browser attaches on
+ *          every same-origin request (`credentials: "include"`). `remote` /
+ *          cookie auth. If bootstrap 401s, the response carries
+ *          `X-Idapt-Authorize-Url` and we navigate the browser through the
+ *          consent round-trip.
+ *
+ * If the bootstrap endpoint is unreachable (the app is NOT served by Idapt —
+ * a static host, `file://`, etc.), `connect()` throws: a browser app must run
+ * on Idapt. There is no IndexedDB / relative-fetch degradation.
+ *
+ * In the cookie-bootstrap flow the `ap_` key never exists anywhere
+ * JS-readable at all — it lives only in the httpOnly app-key cookie, which the
+ * browser attaches automatically. Only library mode (mode 1) ever holds a raw
+ * key in JS, and that one is caller-supplied.
+ */
+
+/**
+ * Defaults the bundled IIFE wires in at build time via sentinel replacement.
+ * Library consumers can override both via `ConnectOptions`.
+ */
+interface DefaultConnectConfig {
+    apiUrl: string;
+    browserAppDomain: string;
+}
+/**
+ * Error thrown by connect() when the browser has been navigated away
+ * to `/app-authorize`. The call-site (SDK boot code) uses the tag to
+ * distinguish "connect will never complete" from genuine failures —
+ * e.g. to keep the overlay visible with an install CTA while
+ * navigation is in-flight.
+ */
+interface IdaptRedirectingError extends Error {
+    __redirecting: true;
+}
+declare function makeConnect(defaults: DefaultConnectConfig): (options?: ConnectOptions) => Promise<IdaptClient>;
+
+/**
+ * App-id and base-URL detection.
+ *
+ * Browser apps are served at `{resId}.{BROWSER_APP_DOMAIN}/...`. Subdomain is
+ * the only supported shape — the path-based `/app/{resId}/` variant was
+ * removed with the auth-unification migration because it cannot carry
+ * the subdomain-scoped `__idapt_app_key` cookie.
+ *
+ * Pure functions → trivially testable with a mock Location.
+ */
+type LocationLike = Pick<Location, "hostname" | "pathname" | "origin" | "href" | "search">;
+/**
+ * Extract the app id from the current window location.
+ *
+ * @param browserAppDomain The configured browser-app domain (e.g. "idapt.host").
+ * @param loc           Location-like. Defaults to window.location.
+ * @returns             Lowercased app id, or empty string if none detected.
+ */
+declare function detectAppId(browserAppDomain: string, loc?: LocationLike): string;
+/**
+ * Build the origin base URL for the app. Used to compute the `redirect`
+ * query param on consent / escalate redirects back to the app.
+ */
+declare function getAppBaseUrl(_browserAppDomain: string, loc?: LocationLike): string;
+
+/**
+ * Connect to Idapt from a browser app. Defaults to the cookie-bootstrap flow on
+ * an app subdomain; pass `{ key }` for library/bearer mode. Shadows the generic
+ * `@idapt/sdk` `connect`. Throws if the app is not running on Idapt.
+ */
+declare function connect(options?: ConnectOptions): Promise<IdaptClient>;
+/** Namespace object for consumers that prefer `Idapt.connect()` style. */
+declare const Idapt: {
+    connect: typeof connect;
+};
+
+export { AiGatewayApi, AiGatewayProvider, type AiGatewayProvidersOptions, type AiGatewayUsageOptions, AiGatewayUsageRow, AuthError, CallOptions, ConflictError, ConnectOptions, DataStore, DataStoreCreateFolderInput, DataStoreUploadInput, type DefaultConnectConfig, DeletedResponse, File, FileUploadResult, HttpContext, Idapt, IdaptClient, type IdaptClientOptions, IdaptError, type IdaptErrorCode, type IdaptErrorInit, type IdaptErrorSubCode, type IdaptErrorType, type IdaptRedirectingError, InvalidRequestError, type LocationLike, NetworkError, NotFoundError, PermissionError, RateLimitError, RemoteDataStore, ServerError, ServiceUnavailableError, VERSION, WriteOptions, connect, detectAppId, errorFromStatus, getAppBaseUrl, makeConnect };