js-bao-wss-client 2.2.0-alpha.14 → 2.2.0-alpha.15

package/README.md

@@ -18,7 +18,6 @@ A TypeScript/JavaScript client library for js-bao-wss that provides HTTP APIs an
 - **Analytics**: Buffered event logging API with optional automatic lifecycle events
 - **Blob Storage**: Upload/list/get/downloadUrl/delete per document with offline cache
 - **Server Functions**: Invoke your app's server functions, start and wait on long-running runs, and join the channels they authorize
-- **LLM**: Chat API and model listing _(deprecated — run a managed prompt from a server function (`ctx.prompts.run`) instead)_
 - **Offline-first Open**: Non-blocking open with IndexedDB-backed cache
 - **Offline Blob Cache**: Cache API + IndexedDB backed uploads/reads with eviction and retry
 - **Network Controls**: Online/offline modes, reachability, connection control
@@ -595,7 +594,6 @@ The client exposes a buffered analytics queue that batches events, retries on re
 - `client.analytics.logEvent({ action, feature, context_json?, ... })`: enqueue a single event. `context_json` accepts an object (auto-serialized) or a JSON string.
 - `client.analytics.flush()`: attempt to send the queue immediately; also runs automatically on reconnect and right before unload/destroy.
 - `client.analytics.setPlanOverride(plan)` and `.setAppVersionOverride(version)`: stamp metadata onto every subsequent event until you clear or replace it.
-- `client.getLlmAnalyticsContext()`: returns `{ logEvent, isEnabled }` when any LLM auto phases are enabled so higher-level features can coordinate their own analytics.
 
 Queued events are persisted in IndexedDB when offline storage is active, so short offline windows or reloads do not drop data. Everything funnels through the same `analytics.batch` WebSocket channel used by the live event test.
 
@@ -608,9 +606,6 @@ All automatic emitters are on by default; pass `analyticsAutoEvents` when constr
 - `sync_error` (`"sync"`, toggle: `analyticsAutoEvents.syncErrors.enabled`): records the `documentId` and `reason` when flush/send attempts fail (with interval throttling).
 - `blob_upload_started` / `blob_upload_succeeded` / `blob_upload_failed` (`"blobs"`, toggles: `analyticsAutoEvents.blobUploads.{start|success|failure}`): include blob/document identifiers, attempt counts, byte size, and retry details (with truncated error text on failure).
 - `session_end` (`"session"`, toggle: `analyticsAutoEvents.sessionEnd`): emitted on `beforeunload` and `client.destroy()`, including `duration_ms` and exit reason.
-- `prompt_started` / `prompt_succeeded` / `prompt_failed` (`"llm"` or `"gemini"`, toggles: `analyticsAutoEvents.llm.{start|success|failure}` and `analyticsAutoEvents.gemini.{start|success|failure}`): unified prompt lifecycle events emitted by `client.llm.chat()` and `client.gemini.generate()`/`client.gemini.countTokens()`. The `feature` field distinguishes the provider.
-
-When `analyticsAutoEvents.llm` enables any of `start`, `success`, or `failure`, `client.getLlmAnalyticsContext()` becomes non-null so LLM helpers can emit structured events without guessing configuration. `analyticsAutoEvents.gemini` controls `client.getGeminiAnalyticsContext()`, which powers automatic logging inside the Gemini namespace.
 
 **Removed events** (no longer emitted, and their option flags have been removed from `analyticsAutoEvents`): `client_boot` (`boot`), `first_doc_open` (`firstDocOpen`), `first_doc_edit` (`firstDocEdit`), `offline_recovery` (`offlineRecovery`), `service_worker_control` / `service_worker_token_update` (`serviceWorker`), `llm_request_*`, `gemini_request_*`.
 
@@ -621,7 +616,7 @@ const client = await initializeClient({
   ...options,
   analyticsAutoEvents: {
     blobUploads: { start: false, success: true, failure: true },
-    llm: { start: true, success: true, failure: false },
+    sessionEnd: false,
   },
 });
 ```
@@ -1802,142 +1797,6 @@ const user = await client.users.getBasic("u01H...");
 console.log(user.name, user.email, user.appRole);
 ```
 
-## Large Language Models (LLM)
-
-> **Deprecated.** The direct LLM client API (`client.llm.*`) is deprecated and will be removed in a future major release. Run a managed prompt from a server function (`ctx.prompts.run`) instead.
-
-```typescript
-// List available models
-const { models, defaultModel } = await client.llm.models();
-console.log("Default model:", defaultModel);
-
-// Basic chat
-const reply = await client.llm.chat({
-  // model is optional; uses server default when omitted
-  messages: [
-    { role: "system", content: "You are a helpful assistant." },
-    { role: "user", content: "Summarize: Collaborative editing with Yjs." },
-  ],
-  temperature: 0.2,
-  max_tokens: 512,
-  reasoning: {
-    effort: "medium",
-    exclude: false,
-  },
-});
-console.log(reply.content);
-
-// Chat with image attachment (base64-encoded PNG)
-const imageBase64 = await loadImageAsBase64("/path/to/screenshot.png");
-const imageReply = await client.llm.chat({
-  messages: [
-    {
-      role: "system",
-      content: "You analyze screenshots and respond helpfully.",
-    },
-    { role: "user", content: "Describe what you see in this image." },
-  ],
-  attachments: [
-    {
-      type: "image",
-      mime: "image/png",
-      base64: imageBase64,
-    },
-  ],
-});
-console.log(imageReply.content);
-```
-
-## Gemini
-
-> **Deprecated.** The direct Gemini client API (`client.gemini.*`) is deprecated and will be removed in a future major release. Run a managed prompt from a server function (`ctx.prompts.run`) instead.
-
-```typescript
-// Text generation with optional structured output
-const result = await client.gemini.generate({
-  messages: [
-    {
-      role: "system",
-      parts: [{ type: "text", text: "Reply in JSON with keys title and summary." }],
-    },
-    {
-      role: "user",
-      parts: [{ type: "text", text: "Summarize collaborative editing with Yjs." }],
-    },
-  ],
-  structuredOutput: {
-    responseMimeType: "application/json",
-    responseJsonSchema: {
-      type: "object",
-      properties: {
-        title: { type: "string" },
-        summary: { type: "string" },
-      },
-      required: ["title", "summary"],
-    },
-  },
-});
-console.log(result.message.parts[0].text);
-
-// Multimodal prompt with inline image data
-const screenshot = await loadImageAsBase64("/path/to/screenshot.png");
-await client.gemini.generate({
-  messages: [
-    {
-      role: "user",
-      parts: [
-        { type: "text", text: "Describe this screenshot." },
-        { type: "image", mimeType: "image/png", base64Data: screenshot },
-      ],
-    },
-  ],
-});
-
-// Raw passthrough using Google's payload schema
-const rawPayload = {
-  contents: [
-    {
-      role: "user",
-      parts: [
-        {
-          text: "Summarize this JSON.",
-        },
-        {
-          inline_data: {
-            mimeType: "application/json",
-            data: someBase64Json,
-          },
-        },
-      ],
-    },
-  ],
-};
-const rawResponse = await client.gemini.generateRaw({
-  model: "models/gemini-2.5-flash",
-  body: rawPayload,
-});
-console.log(rawResponse.candidates?.[0]?.content);
-
-// Token usage estimation
-const tokens = await client.gemini.countTokens({
-  model: "models/gemini-2.5-flash",
-  messages: [{ role: "user", parts: [{ type: "text", text: "How many tokens?" }] }],
-});
-console.log(tokens.totalTokens);
-```
-
-### Gemini Configuration & Notes
-
-- `client.gemini` proxies to server-side routes:
-  - `GET /gemini/models` → `client.gemini.models()`
-  - `POST /gemini/generate` → `client.gemini.generate(...)`
-  - `POST /gemini/count-tokens` → `client.gemini.countTokens(...)`
-  - `POST /gemini/generate-raw` → `client.gemini.generateRaw({ model, body })`
-  These endpoints run server-side, so browser clients never see Google credentials.
-- Inline multimodal content uses base64 `parts` (text, image, file), up to about 25 MB per request.
-- Structured output leverages `generationConfig.responseMimeType` plus optional `responseSchema` / `responseJsonSchema` so Gemini can return deterministic JSON. The full server response is always available via the `raw` field when you need annotations or safety metadata.
-- Error handling surfaces `JsBaoError` with `code: "GEMINI_ERROR"`; the `details` property contains the raw upstream payload so you can log or render troubleshooting info.
-
 ## Server Functions
 
 A server function is TypeScript your app's team writes in its config tree and

package/dist/JsBaoClient.d.ts

@@ -20,8 +20,6 @@ import { DocumentsAPI, DocumentContext, type DocumentInfo, type ResolveAliasPara
 import { type CacheFacade } from "./api/cacheFacade";
 import { MeAPI } from "./api/meApi";
 import { SessionAPI } from "./api/sessionApi";
-import { LlmAPI } from "./api/llmApi";
-import { GeminiAPI } from "./api/geminiApi";
 import { UsersAPI } from "./api/usersApi";
 import { DatabasesAPI } from "./api/databasesApi";
 import { GroupsAPI } from "./api/groupsApi";
@@ -56,15 +54,12 @@ export type { AppInvitationInfo, InvitationQuota, CreateInvitationParams, Invita
 export type { DoDb, DOClientEngine, ModelIdentifier, ModelFieldInfo, SaveOptions } from "js-bao/client";
 export type { DiscoveredSchema, DiscoveredModel, DiscoveredField, DiscoveredConstraint, DiscoveredRelationship } from "js-bao";
 export type { CacheFacade } from "./api/cacheFacade";
-export type { ReasoningOptions, LlmChatOptions } from "./api/llmApi";
 export type { AnalyticsEventInput } from "./internal/analyticsQueue";
 export { ANALYTICS_UNAUTHENTICATED_USER } from "./internal/analyticsQueue";
 export type { DocumentBlobContext, BlobUploadSourceOptions, BlobUploadResult, BlobListResult, BlobUploadStatus, BlobReadOptions, BlobPrefetchOptions, BlobProxyUrlOptions, BlobDisposition, } from "./internal/blobManager";
 export type { DocumentsAPI, DocumentContext, DocumentAliasesAPI, DocumentIngestsAPI, DocumentSnapshotsAPI, } from "./api/documentsApi";
 export type { DatabasesAPI } from "./api/databasesApi";
 export type { CollectionsAPI } from "./api/collectionsApi";
-export type { GeminiAPI } from "./api/geminiApi";
-export type { LlmAPI } from "./api/llmApi";
 export type { MeAPI } from "./api/meApi";
 export type { SessionAPI } from "./api/sessionApi";
 export type { UsersAPI } from "./api/usersApi";
@@ -86,7 +81,6 @@ export type { CreateGroupTypeConfigParams, UpdateGroupTypeConfigParams, } from "
 export type { CreateRuleSetParams, DebugRuleSetParams, ListRuleSetsOptions, TestRuleSetParams, UpdateRuleSetParams, } from "./api/ruleSetsApi";
 export type { GetMeOptions, UpdateMeParams } from "./api/meApi";
 export type { GetUserOptions } from "./api/usersApi";
-export type { GeminiCandidate, GeminiFilePart, GeminiGenerationConfig, GeminiImagePart, GeminiSafetySetting, GeminiTextPart, } from "./api/geminiApi";
 export type { AggregateGroupByEntry, CreateOperationParamsOf, DatabaseOperationInfoOf, ObjectOrParamsRef, PipelineAggregateStep, PipelineCountStep, PipelineQueryStep, } from "./api/operationDefinition";
 export type { NotificationTokenAttempt } from "./api/notificationsApi";
 export type { InvitationsAPI, InvitationListOptions, DeferredGrantListOptions, } from "./api/invitationsApi";
@@ -106,7 +100,7 @@ export type { ResourceMetadataReadResult, ResourceMetadataWriteResult, ResourceM
  * `analyticsAutoEvents` in {@link JsBaoClientOptions}. Every category is
  * enabled by default; set a flag (or a category's sub-flags) to `false` to
  * opt out. Categories cover daily auth, return-to-active resumes, sync
- * errors, blob upload lifecycle, session end, and LLM / Gemini calls.
+ * errors, blob upload lifecycle, and session end.
  */
 export interface AnalyticsAutoEventsOptions {
     dailyAuth?: boolean;
@@ -122,18 +116,7 @@ export interface AnalyticsAutoEventsOptions {
         failure?: boolean;
     };
     sessionEnd?: boolean;
-    llm?: boolean | {
-        start?: boolean;
-        success?: boolean;
-        failure?: boolean;
-    };
-    gemini?: boolean | {
-        start?: boolean;
-        success?: boolean;
-        failure?: boolean;
-    };
 }
-export type { GeminiRole, GeminiContentPart, GeminiMessage, GeminiPromptOptions, GeminiGenerateOptions, GeminiGenerateResult, GeminiModelSummary, GeminiStructuredOutput, GeminiGenerateRawOptions, } from "./api/geminiApi";
 /**
  * Request passed to `client.integrations.call()`. Identifies the integration
  * by key and describes the HTTP request to send through the integration
@@ -2520,18 +2503,6 @@ export declare class JsBaoClient extends Observable<any> {
     /** Sub-API for session management (sign in, sign out, token refresh).
      * @group Sub-APIs */
     session: SessionAPI;
-    /** Sub-API for LLM (large language model) operations.
-     * @group Sub-APIs
-     * @deprecated The direct LLM client API is deprecated and will be removed in a
-     * future major release. Run a managed prompt from a
-     * server function instead: `ctx.prompts.run` (see the Server Functions guide). */
-    llm: LlmAPI;
-    /** Sub-API for Gemini model operations.
-     * @group Sub-APIs
-     * @deprecated The direct Gemini client API is deprecated and will be removed in
-     * a future major release. Run a managed prompt from a
-     * server function instead: `ctx.prompts.run` (see the Server Functions guide). */
-    gemini: GeminiAPI;
     /** Sub-API for managing app users.
      * @group Sub-APIs */
     users: UsersAPI;
@@ -3049,18 +3020,6 @@ export declare class JsBaoClient extends Observable<any> {
     private handleBlobUploadComplete;
     private handleBlobUploadFailed;
     private logSessionEndEvent;
-    /** Get the analytics context for LLM operations.
-     * @group Configuration */
-    getLlmAnalyticsContext(): {
-        logEvent: (event: Omit<AnalyticsEventInput, "user_ulid">) => void;
-        isEnabled: (phase?: "start" | "success" | "failure") => boolean;
-    } | null;
-    /** Get the analytics context for Gemini operations.
-     * @group Configuration */
-    getGeminiAnalyticsContext(): {
-        logEvent: (event: Omit<AnalyticsEventInput, "user_ulid">) => void;
-        isEnabled: (phase?: "start" | "success" | "failure") => boolean;
-    } | null;
     private sanitizeOverride;
     private readEnvNumber;
     /** Check if a document is synced with the server.

package/dist/JsBaoClient.js

@@ -33,8 +33,6 @@ import { DocumentsAPI, } from "./api/documentsApi";
 import { createCacheFacade } from "./api/cacheFacade";
 import { MeAPI } from "./api/meApi";
 import { SessionAPI } from "./api/sessionApi";
-import { LlmAPI } from "./api/llmApi";
-import { GeminiAPI } from "./api/geminiApi";
 import { UsersAPI } from "./api/usersApi";
 import { DatabasesAPI } from "./api/databasesApi";
 import { GroupsAPI } from "./api/groupsApi";
@@ -1057,38 +1055,6 @@ export class JsBaoClient extends Observable {
         const blobUploadsFailure = typeof blobUploadsOption.failure === "boolean"
             ? blobUploadsOption.failure
             : true;
-        const llmOption = analyticsAuto.llm;
-        let llmStart = true;
-        let llmSuccess = true;
-        let llmFailure = true;
-        if (llmOption !== undefined) {
-            if (typeof llmOption === "boolean") {
-                llmStart = llmOption;
-                llmSuccess = llmOption;
-                llmFailure = llmOption;
-            }
-            else if (typeof llmOption === "object" && llmOption !== null) {
-                llmStart = llmOption.start !== false;
-                llmSuccess = llmOption.success !== false;
-                llmFailure = llmOption.failure !== false;
-            }
-        }
-        const geminiOption = analyticsAuto.gemini;
-        let geminiStart = true;
-        let geminiSuccess = true;
-        let geminiFailure = true;
-        if (geminiOption !== undefined) {
-            if (typeof geminiOption === "boolean") {
-                geminiStart = geminiOption;
-                geminiSuccess = geminiOption;
-                geminiFailure = geminiOption;
-            }
-            else if (typeof geminiOption === "object" && geminiOption !== null) {
-                geminiStart = geminiOption.start !== false;
-                geminiSuccess = geminiOption.success !== false;
-                geminiFailure = geminiOption.failure !== false;
-            }
-        }
         this.analyticsAutoEventsConfig = {
             dailyAuth: analyticsAuto.dailyAuth !== false,
             returnActive: analyticsAuto.returnActive !== false,
@@ -1102,16 +1068,6 @@ export class JsBaoClient extends Observable {
                 success: blobUploadsSuccess,
                 failure: blobUploadsFailure,
             },
-            llm: {
-                start: llmStart,
-                success: llmSuccess,
-                failure: llmFailure,
-            },
-            gemini: {
-                start: geminiStart,
-                success: geminiSuccess,
-                failure: geminiFailure,
-            },
             sessionEnd: analyticsAuto.sessionEnd !== false,
         };
         this.offlineStore = new OfflineStore(logger);
@@ -1221,8 +1177,6 @@ export class JsBaoClient extends Observable {
         this.documents = new DocumentsAPI(this, this.docManager, DEFAULT_AVAILABILITY_WAIT_MS, logger);
         this.me = new MeAPI(this);
         this.session = new SessionAPI(this);
-        this.llm = new LlmAPI(this);
-        this.gemini = new GeminiAPI(this);
         this.users = new UsersAPI(this);
         this.dbSubscriptions = new DatabaseSubscriptionRegistry(logger);
         // Wire the origin lookups so the registry can synthesize per-recipient
@@ -2305,6 +2259,11 @@ export class JsBaoClient extends Observable {
                     logger.log(`[JsBaoClient] Created ${tomlModels.length} model classes from schemaToml`);
                 }
                 catch (err) {
+                    // #3719 — a unique constraint on a stringset field is a declaration
+                    // the author has to fix, not a parse hiccup: surface it as the init
+                    // failure (`jsBaoInitError`) rather than starting with no models.
+                    if (err?.name === "UniqueStringsetError")
+                        throw err;
                     logger.warn("[JsBaoClient] Failed to parse schemaToml:", err);
                 }
             }
@@ -4632,50 +4591,6 @@ export class JsBaoClient extends Observable {
             },
         });
     }
-    /** Get the analytics context for LLM operations.
-     * @group Configuration */
-    getLlmAnalyticsContext() {
-        const config = this.analyticsAutoEventsConfig.llm;
-        if (!config.start && !config.success && !config.failure) {
-            return null;
-        }
-        return {
-            logEvent: (event) => this.logAnalyticsEvent(event),
-            isEnabled: (phase) => {
-                if (!phase)
-                    return config.start || config.success || config.failure;
-                if (phase === "start")
-                    return config.start;
-                if (phase === "success")
-                    return config.success;
-                if (phase === "failure")
-                    return config.failure;
-                return true;
-            },
-        };
-    }
-    /** Get the analytics context for Gemini operations.
-     * @group Configuration */
-    getGeminiAnalyticsContext() {
-        const config = this.analyticsAutoEventsConfig.gemini;
-        if (!config.start && !config.success && !config.failure) {
-            return null;
-        }
-        return {
-            logEvent: (event) => this.logAnalyticsEvent(event),
-            isEnabled: (phase) => {
-                if (!phase)
-                    return config.start || config.success || config.failure;
-                if (phase === "start")
-                    return config.start;
-                if (phase === "success")
-                    return config.success;
-                if (phase === "failure")
-                    return config.failure;
-                return true;
-            },
-        };
-    }
     sanitizeOverride(value) {
         if (typeof value !== "string")
             return undefined;

package/dist/agents/sessionModelRuntime.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The decode and encode rules of the platform session models — #3802.
+ *
+ * `sessionModels.generated.ts` renders one spec per model from the platform
+ * schema (`src/agents/session-document-schema.ts`) and calls through here, so
+ * the rules live once rather than once per column. Rows are flat, so most of
+ * a record is the row's own columns; the rules are the few places a value is
+ * interpreted:
+ *
+ * - A scalar column is copied as read. A number column holding a non-number,
+ *   a string or date column holding a non-string, and a boolean column
+ *   holding anything but a boolean or a number read as `undefined`; a number
+ *   in a boolean column is `false` for `0` and `true` otherwise (the Swift
+ *   client's `rowBoolValue`).
+ * - An enum outside its vocabulary reads as `"unknown"`; the raw string stays
+ *   on the record's `row`.
+ * - A part whose `kind` is unknown is the opaque `{ kind: "unknown", rawKind,
+ *   row }`.
+ * - A stringset reads as its string members in stored order, from an array or
+ *   a js-bao `StringSet`; an absent one is `[]`.
+ * - A JSON column's absent or malformed text is `undefined`. Valid text is
+ *   the value (`any`), an object keeping every key (`object`), or the queue's
+ *   well-formed entries (`queue`); valid text of the wrong top-level type is
+ *   `{}` or `[]` where the column says so, else `undefined`.
+ * - Columns the schema does not declare are neither decoded nor carried.
+ * - A row missing a required scalar column does not decode.
+ * - Encoding writes a column verbatim from the record's `row` when the value
+ *   decoded from it equals the record's value, so an unchanged record comes
+ *   back exactly as it was read; a changed value is written canonically.
+ */
+import { autoRegisterModel } from "js-bao";
+type ModelClass = Parameters<typeof autoRegisterModel>[0];
+export type SessionModelColumn = {
+    kind: "id";
+} | {
+    kind: "string" | "number" | "boolean" | "date";
+    required?: boolean;
+} | {
+    kind: "enum";
+    values: string[];
+    required?: boolean;
+} | {
+    kind: "stringset";
+} | {
+    kind: "json";
+    shape: "any" | "object" | "queue";
+    emptyOnWrongType?: boolean;
+};
+export interface SessionModelSpec {
+    name: string;
+    columns: {
+        [column: string]: SessionModelColumn;
+    };
+    discriminator?: {
+        column: string;
+        variants: {
+            [kind: string]: {
+                columns: string[];
+                enums?: {
+                    [column: string]: string[];
+                };
+            };
+        };
+    };
+}
+/** One author waiting in the session queue, with their batch in order. */
+export interface PrimitiveQueueEntry {
+    userId: string;
+    messageIds: string[];
+}
+/**
+ * The text a JSON column stores: `JSON.stringify` with no whitespace — the
+ * same bytes the session object writes for the same value. `null` is a value;
+ * `undefined` has no text, so omit the column instead.
+ */
+export declare function encodeJsonColumn(value: unknown): string;
+/** A JSON column's value, or `undefined` when it is absent or not JSON. */
+export declare function decodeJsonColumn(text: unknown): unknown;
+type Row = Record<string, unknown>;
+export type DecodedRow = {
+    ok: true;
+    record: Record<string, unknown>;
+} | {
+    ok: false;
+    column: string;
+};
+/** One stored column's decoded value; `undefined` when it has none. */
+export declare function decodeColumn(column: SessionModelColumn, raw: unknown): unknown;
+/**
+ * Decode one row (a model instance or plain attrs). Fails naming the first
+ * required scalar column the row cannot supply.
+ */
+export declare function decodeModelRow(spec: SessionModelSpec, input: object): DecodedRow;
+/** The error a session row that cannot be decoded throws. */
+export declare function sessionRowInvalid(column: string): Error & {
+    code: "AGENT_SESSION_ROW_INVALID";
+    column: string;
+};
+/**
+ * Structural equality over decoded values; an `undefined` key is absent. Only
+ * own keys count, so a JSON `__proto__` key never matches an inherited one.
+ */
+export declare function sessionValuesEqual(a: unknown, b: unknown): boolean;
+/**
+ * A record's row attrs. A column whose value still equals what its `row`
+ * decodes to is written as the row held it (its text, its array, its raw
+ * value, or absent); anything else is written from the value. An `unknown`
+ * enum with no source to copy is written as the text `unknown`, which decodes
+ * back to the same value. An opaque part writes its common columns the same
+ * way and every other column from its `row`, with `rawKind` as its kind.
+ */
+export declare function encodeModelRecord(spec: SessionModelSpec, record: Record<string, unknown>): Row;
+/** The error `agentSessionModels()` throws when an app class holds a platform name. */
+export declare function sessionModelNameTaken(model: string): Error & {
+    code: "AGENT_SESSION_MODEL_NAME_TAKEN";
+    model: string;
+};
+/**
+ * Register the platform classes with js-bao's registry, refusing — before
+ * anything is registered — when an app class already holds one of the names.
+ * js-bao itself would only warn and overwrite the app's class.
+ */
+export declare function registerSessionModels(models: ReadonlyArray<ModelClass>): void;
+export {};