js-bao 0.3.0 → 0.4.0

package/dist/cloudflare-do.d.cts

@@ -1,3 +1,5 @@
+import * as Y from 'yjs';
+
 interface RefersToRelationshipConfig {
     type: "refersTo";
     model: string;
@@ -716,12 +718,22 @@ interface QueryOptions {
     direction?: 1 | -1;
     include?: IncludeSpec[];
 }
+interface PaginatedResult<T> {
+    data: T[];
+    nextCursor?: string;
+    prevCursor?: string;
+    hasMore: boolean;
+}
 interface TranslatedQuery {
     sql: string;
     params: any[];
     sortFields: string[];
     sortDirections?: (1 | -1)[];
 }
+type ProjectedResult<T, P extends ProjectionSpec> = {
+    [K in keyof P]: K extends keyof T ? T[K] : never;
+};
+type QueryResult<T, P extends ProjectionSpec | undefined> = P extends ProjectionSpec ? ProjectedResult<T, P> : T;
 
 /**
  * JSON Query Translator
@@ -849,18 +861,18 @@ declare class JsonQueryTranslator {
  * Describes a StringSet membership check in a groupBy clause.
  * Groups records by whether they have a specific value in a StringSet field.
  */
-interface StringSetMembership {
+interface StringSetMembership$1 {
     field: string;
     contains: string;
 }
 /**
  * A groupBy field can be a plain field name or a StringSet membership check.
  */
-type GroupByField = string | StringSetMembership;
+type GroupByField$1 = string | StringSetMembership$1;
 /**
  * An aggregation operation (count, sum, avg, min, max).
  */
-interface AggregationOperation {
+interface AggregationOperation$1 {
     type: "count" | "sum" | "avg" | "min" | "max";
     /** Required for sum, avg, min, max; not used for count */
     field?: string;
@@ -868,9 +880,9 @@ interface AggregationOperation {
 /**
  * Options for an aggregation query.
  */
-interface AggregationOptions {
-    groupBy: GroupByField[];
-    operations: AggregationOperation[];
+interface AggregationOptions$1 {
+    groupBy: GroupByField$1[];
+    operations: AggregationOperation$1[];
     filter?: DocumentFilter;
     limit?: number;
     sort?: {
@@ -883,7 +895,7 @@ interface AggregationOptions {
 /**
  * Result of an aggregation query — nested object keyed by group values.
  */
-type AggregationResult = Record<string, any> | Record<string, any>[];
+type AggregationResult$1 = Record<string, any> | Record<string, any>[];
 
 /**
  * Hook type definitions for Durable Object access control.
@@ -1084,10 +1096,10 @@ interface UniqueConstraintListResponse {
 }
 interface AggregateRequest {
     modelName: string;
-    options: AggregationOptions;
+    options: AggregationOptions$1;
 }
 interface AggregateResponse {
-    result: AggregationResult;
+    result: AggregationResult$1;
 }
 interface SyncIndexesRequest {
     models: Array<{
@@ -1236,7 +1248,7 @@ declare function createDatabaseDO(config?: DatabaseDOConfig): {
         _handleStringSetRemove(request: Request, _docId: string): Promise<Response>;
         _handleAggregate(request: Request, docId: string): Promise<Response>;
         /** @internal — Build SQL for StringSet facet aggregation */
-        _buildStringSetFacetSql(modelName: string, facetField: string, aggOptions: AggregationOptions, filter: DocumentFilter, translator: JsonQueryTranslator): {
+        _buildStringSetFacetSql(modelName: string, facetField: string, aggOptions: AggregationOptions$1, filter: DocumentFilter, translator: JsonQueryTranslator): {
             sql: string;
             params: any[];
         };
@@ -1244,7 +1256,7 @@ declare function createDatabaseDO(config?: DatabaseDOConfig): {
         _buildRegularAggregationSql(modelName: string, regularGroupBy: string[], stringSetMemberships: Array<{
             field: string;
             contains: string;
-        }>, aggOptions: AggregationOptions, filter: DocumentFilter, translator: JsonQueryTranslator): {
+        }>, aggOptions: AggregationOptions$1, filter: DocumentFilter, translator: JsonQueryTranslator): {
             sql: string;
             params: any[];
             aliasMap: Array<{
@@ -1254,13 +1266,13 @@ declare function createDatabaseDO(config?: DatabaseDOConfig): {
             }>;
         };
         /** @internal — Extract operation value(s) from a row. Flattens single-op results. */
-        _extractOpValue(row: any, operations: AggregationOptions["operations"]): any;
+        _extractOpValue(row: any, operations: AggregationOptions$1["operations"]): any;
         /** @internal — Process raw aggregation rows into nested result */
-        _processAggregationResults(results: any[], aggOptions: AggregationOptions, aliasMap: Array<{
+        _processAggregationResults(results: any[], aggOptions: AggregationOptions$1, aliasMap: Array<{
             alias: string;
             field: string;
             contains: string;
-        }>, stringSetFacetField: string | null): AggregationResult;
+        }>, stringSetFacetField: string | null): AggregationResult$1;
         /** @internal */
         /** @internal — Batch sync: compare desired indexes against _indexes table, register missing */
         _handleIndexesSync(request: Request): Promise<Response>;
@@ -1395,4 +1407,494 @@ interface Env {
  */
 declare function handleRequest(request: Request, env: Env): Promise<Response>;
 
-export { type AfterQueryContext, type AfterQueryResult, type AggregateRequest, type AggregateResponse, type AggregationOperation, type AggregationOptions, type AggregationResult, type BatchOperation, type BatchOperationResult, type BatchRequest, type BatchResponse, type BeforeDeleteContext, type BeforeQueryContext, type BeforeQueryResult, type BeforeSaveContext, type CountRequest, type CountResponse, type DatabaseDOConfig, type DatabaseDOHooks, type DeleteRequest, type DeleteResponse, type DocumentDOConfig, type DropIndexRequest, type DropIndexResponse, type DropUniqueConstraintRequest, type DropUniqueConstraintResponse, DurableObjectEngine, type DurableObjectEngineOptions, type DurableObjectId, type DurableObjectNamespace, type DurableObjectState, type DurableObjectStorage, type DurableObjectStub, type Env, type ErrorResponse, type GroupByField, type HookContext, type HookResult, type IncrementRequest, type IncrementResponse, type IndexEntry, type IndexListResponse, JsonQueryTranslator, type JsonQueryTranslatorOptions, JsonSchemaDDL, type JsonSchemaOptions, type PatchRequest, type PatchResponse, type QueryRequest, type QueryResponse, type RegisterIndexRequest, type RegisterIndexResponse, type RegisterUniqueConstraintRequest, type RegisterUniqueConstraintResponse, type SaveRequest, type SaveResponse, type SchemaConstraintInfo, type SchemaFieldInfo, type SchemaModelInfo, type SchemaResponse, type SqlStorage, type SqlStorageCursor, type StringSetMembership, type StringSetUpdateRequest, type StringSetUpdateResponse, type SyncIndexesRequest, type SyncIndexesResponse, type UniqueConstraintEntry, type UniqueConstraintListResponse, createDatabaseDO, createDocumentDO, handleRequest };
+/**
+ * YDoc Schema Discovery
+ *
+ * Reads _meta_* YMaps from a YDoc and returns a plain JSON description
+ * of the schema.  Works with any YDoc — no BaseModel or database needed.
+ *
+ * Usage:
+ *   import { discoverSchema } from "js-bao";
+ *   const schema = discoverSchema(yDoc);
+ */
+
+interface DiscoveredField {
+    type: string;
+    indexed?: boolean;
+    unique?: boolean;
+    required?: boolean;
+    default?: string | number | boolean;
+    autoAssign?: boolean;
+    maxLength?: number;
+    maxCount?: number;
+}
+interface DiscoveredConstraint {
+    type: string;
+    fields: string[];
+}
+interface DiscoveredRelationship {
+    type: string;
+    model: string;
+    [key: string]: any;
+}
+interface DiscoveredModel {
+    fields: Record<string, DiscoveredField>;
+    constraints?: Record<string, DiscoveredConstraint>;
+    relationships?: Record<string, DiscoveredRelationship>;
+}
+interface DiscoveredSchema {
+    models: Record<string, DiscoveredModel>;
+}
+/**
+ * Discover the schema embedded in a YDoc by reading its `_meta_*` maps.
+ *
+ * Returns a plain JSON object describing every model that has metadata.
+ * Does not require BaseModel, a database, or any schema registration —
+ * just a Y.Doc.
+ */
+declare function discoverSchema(yDoc: Y.Doc): DiscoveredSchema;
+/**
+ * List model names that have data in the YDoc (non-`_` prefixed top-level maps).
+ */
+declare function discoverModelNames(yDoc: Y.Doc): string[];
+/**
+ * Convert a DiscoveredSchema to a TOML string matching the js-bao
+ * schema format.
+ *
+ * Usage:
+ *   const schema = discoverSchema(yDoc);
+ *   const toml = schemaToToml(schema);
+ */
+declare function schemaToToml(schema: DiscoveredSchema): string;
+
+interface StringSetChangeTracker {
+    markStringSetChange(fieldName: string, operation: "add" | "remove" | "clear", value?: string): void;
+}
+
+type DocumentPermissionHint = "read" | "read-write";
+interface SaveOptions {
+    targetDocument?: string;
+    forceWrite?: boolean;
+    upsertOn?: string;
+}
+
+declare class DocumentQueryTranslator {
+    private modelName;
+    private schema;
+    private tableName;
+    private quotedTableName;
+    private fieldSqlCache;
+    constructor(modelName: string, schema: Map<string, FieldOptions>);
+    private getQuotedField;
+    /**
+     * Translate document filter and options to SQL for find operations
+     */
+    translateFind(filter: DocumentFilter, options?: QueryOptions): TranslatedQuery;
+    /**
+     * Translate document filter to SQL for count operations
+     */
+    translateCount(filter: DocumentFilter, options?: Pick<QueryOptions, "documents">): {
+        sql: string;
+        params: any[];
+    };
+    /**
+     * Translate document filter to SQL WHERE clause
+     */
+    translateFilter(filter: DocumentFilter): {
+        sql: string;
+        params: any[];
+    };
+    /**
+     * Translate logical operators ($and, $or)
+     */
+    private translateLogicalOperator;
+    /**
+     * Translate field condition to SQL
+     */
+    private translateFieldCondition;
+    /**
+     * Translate field operators to SQL
+     */
+    private translateFieldOperators;
+    /**
+     * Translate individual operator to SQL
+     */
+    private translateOperator;
+    /**
+     * Build SELECT clause based on projection
+     */
+    private buildSelectClause;
+    /**
+     * Build LIMIT clause
+     */
+    private buildLimitClause;
+    /**
+     * Build pagination WHERE clause from cursor
+     */
+    private buildPaginationClause;
+    /**
+     * Validate that field exists in schema
+     */
+    private validateField;
+    /**
+     * Validate projection fields
+     */
+    private validateProjection;
+    /**
+     * Validate operator is supported for field type
+     */
+    private validateOperatorForType;
+    /**
+     * Validate field value matches expected type
+     */
+    private validateFieldValue;
+    /**
+     * Validate array values for $in/$nin operators
+     */
+    private validateArrayValues;
+    /**
+     * Check if value is a primitive (not an object with operators)
+     */
+    private isPrimitiveValue;
+    /**
+     * Get the type of a value for validation
+     */
+    private getValueType;
+    /**
+     * Check if value type is compatible with field type
+     */
+    private isTypeCompatible;
+    /**
+     * Convert value for SQLite compatibility
+     */
+    private convertValueForSQLite;
+    private normalizeDocumentIds;
+    private buildDocumentClause;
+}
+
+interface StringSetMembership {
+    field: string;
+    contains: string;
+}
+type GroupByField = string | StringSetMembership;
+interface AggregationOperation {
+    type: "count" | "sum" | "avg" | "min" | "max";
+    field?: string;
+}
+interface AggregationOptions {
+    groupBy: GroupByField[];
+    operations: AggregationOperation[];
+    filter?: DocumentFilter;
+    limit?: number;
+    sort?: {
+        field: string;
+        direction: 1 | -1;
+    };
+}
+type AggregationResult = Record<string, any> | Record<string, any>[];
+interface AggregationAliasDebugInfo {
+    field: string;
+    contains: string;
+    originalAlias: string;
+}
+interface AggregationAliasDetail extends AggregationAliasDebugInfo {
+    alias: string;
+    membershipKey: string;
+}
+interface AggregationQueryPlan {
+    sql: string;
+    params: any[];
+    aliasMetadata?: AggregationAliasDetail[];
+}
+declare enum LogLevel {
+    SILENT = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4,
+    VERBOSE = 5
+}
+declare class BaseModel implements StringSetChangeTracker {
+    static modelName?: string;
+    private static listenersMap;
+    private static modelNameToDefaultDocId;
+    private static globalDefaultDocId;
+    private static defaultDocChangedListeners;
+    private static modelDocMappingChangedListeners;
+    private static readonly DEFAULT_LEGACY_DOC_ID;
+    protected static dbInstance: DatabaseEngine | null;
+    protected static connectedDocuments: Map<string, {
+        yDoc: Y.Doc;
+        permissionHint: DocumentPermissionHint;
+    }>;
+    protected static documentYMaps: Map<string, Y.Map<any>>;
+    private _localChanges;
+    private _isDirty;
+    private _isLoadingFromYjs;
+    private _stringSetFields;
+    protected _constructorProvidedId: boolean;
+    protected _constructorProvidedFields: Set<string>;
+    private _metaDocId;
+    private _metaPermissionHint;
+    /**
+     * Returns the document id this instance is associated with, or null if not resolved yet.
+     */
+    getDocumentId(): string | null;
+    id: string;
+    type: string;
+    static setLogLevel(level: LogLevel): void;
+    static getLogLevel(): LogLevel;
+    static setModelDefaultDocumentId(modelName: string, docId: string): void;
+    static removeModelDefaultDocumentId(modelName: string): void;
+    static clearModelDefaultDocumentIds(): void;
+    static setGlobalDefaultDocumentId(docId: string): void;
+    static clearGlobalDefaultDocumentId(): void;
+    static getModelDefaultDocumentMapping(): Record<string, string>;
+    static getDocumentIdForModel(modelName: string): string | undefined;
+    static getGlobalDefaultDocumentId(): string | undefined;
+    static onDefaultDocChanged(listener: (payload: {
+        previous?: string;
+        current?: string;
+    }) => void): () => void;
+    static onModelDocMappingChanged(listener: (payload: {
+        modelName: string;
+        previous?: string;
+        current?: string;
+    }) => void): () => void;
+    static _clearMappingsForDocId(docId: string): void;
+    private static attachFieldAccessorsSet;
+    static attachFieldAccessors(modelClass: typeof BaseModel, fields: Map<string, FieldOptions>): void;
+    constructor(data?: Partial<any>);
+    private ensureLocalChanges;
+    private hasLocalChange;
+    private getFromYjs;
+    private getValue;
+    private setValue;
+    get isDirty(): boolean;
+    get hasUnsavedChanges(): boolean;
+    private clearLocalChanges;
+    discardChanges(): void;
+    protected validateFieldValue(fieldKey: string, value: any): void;
+    protected validateBeforeSave(): void;
+    getChangedFields(): string[];
+    getOriginalValue(fieldKey: string): any;
+    getCurrentValue(fieldKey: string): any;
+    hasFieldChanged(fieldKey: string): boolean;
+    markStringSetChange(fieldName: string, operation: "add" | "remove" | "clear", value?: string): void;
+    private getStringSetCurrentValues;
+    private getStringSetFromYjs;
+    private getOrCreateStringSet;
+    static initialize(_yDoc: Y.Doc, _db: DatabaseEngine): Promise<void>;
+    static initializeForDocument(yDoc: Y.Doc, db: DatabaseEngine, docId: string, permissionHint: DocumentPermissionHint): Promise<void>;
+    static cleanupDocumentData(docId: string): Promise<void>;
+    static subscribe(callback: () => void): () => void;
+    protected static notifyListeners(): void;
+    /**
+     * Legacy migration method - no longer needed in the new multidoc architecture.
+     * Data migration is now handled during document initialization.
+     */
+    static migrateToNestedYMaps(): Promise<void>;
+    /**
+     * Utility to diff current instance data against YJS nested map data
+     * Returns object with added, modified, and removed fields
+     */
+    protected _diffWithYjsData(): {
+        added: Record<string, any>;
+        modified: Record<string, any>;
+        removed: string[];
+    };
+    /**
+     * Deep equality check for comparing field values
+     */
+    protected _deepEqual(a: any, b: any): boolean;
+    protected static _buildKeyFromValues(fields: string[], keyValues: any[], modelName: string, constraintName: string): string | null;
+    protected _buildUniqueKey(fields: string[], data: Record<string, any>, modelName: string, constraintName: string): string | null;
+    save(options?: SaveOptions): Promise<void>;
+    delete(): Promise<void>;
+    protected getCurrentJSState(): Record<string, any>;
+    protected toJSON(): Record<string, any>;
+    static find<T extends BaseModel>(this: new (...args: any[]) => T, id: string): Promise<T | null>;
+    /**
+     * Document-style query API - returns paginated results
+     */
+    static query<T extends BaseModel, P extends ProjectionSpec | undefined = undefined>(this: new (...args: any[]) => T, filter?: DocumentFilter, options?: QueryOptions & {
+        projection?: P;
+    }): Promise<PaginatedResult<QueryResult<T, P>>>;
+    /**
+     * Main aggregation API - performs grouping, faceting, and statistical operations
+     * @param options Aggregation configuration with groupBy, operations, filter, limit, and sort
+     * @returns Nested object structure with aggregation results
+     *
+     * @example
+     * // Simple facet count
+     * const tagCounts = await Model.aggregate({
+     *   groupBy: ['tags'],
+     *   operations: [{ type: 'count' }]
+     * });
+     * // Result: { red: 15, blue: 8, green: 12 }
+     *
+     * @example
+     * // Multi-dimensional grouping with multiple operations
+     * const categoryStats = await Model.aggregate({
+     *   groupBy: ['category', 'status'],
+     *   operations: [
+     *     { type: 'count' },
+     *     { type: 'sum', field: 'amount' },
+     *     { type: 'avg', field: 'score' }
+     *   ],
+     *   filter: { active: true },
+     *   sort: { field: 'count', direction: 'desc' },
+     *   limit: 10
+     * });
+     *
+     * @example
+     * // StringSet membership grouping
+     * const urgentCounts = await Model.aggregate({
+     *   groupBy: [{ field: 'tags', contains: 'urgent' }],
+     *   operations: [{ type: 'count' }]
+     * });
+     * // Result: { true: 5, false: 23 }
+     */
+    static aggregate<T extends BaseModel>(this: new (...args: any[]) => T, options: AggregationOptions): Promise<AggregationResult>;
+    /**
+     * Build SQL query for structured aggregation
+     */
+    protected static buildAggregationQuery(options: AggregationOptions, schema: any, modelName: string): AggregationQueryPlan;
+    /**
+     * Get the proper database table name (should match database engine naming)
+     */
+    protected static getDatabaseTableName(modelName: string): string;
+    /**
+     * Get the proper database junction table name for StringSet fields
+     */
+    protected static getDatabaseJunctionTableName(modelName: string, fieldName: string): string;
+    private static buildMembershipKey;
+    /**
+     * Build query for StringSet facet counts
+     */
+    protected static buildStringSetFacetQuery(stringSetFields: string[], options: AggregationOptions, translator: DocumentQueryTranslator, modelName: string): AggregationQueryPlan;
+    /**
+     * Build query for regular field aggregation
+     */
+    protected static buildRegularAggregationQuery(regularGroupBy: string[], stringSetMemberships: StringSetMembership[], options: AggregationOptions, translator: DocumentQueryTranslator, modelName: string): AggregationQueryPlan;
+    /**
+     * Process aggregation results into nested structure
+     */
+    protected static processAggregationResults(results: any[], options: AggregationOptions, aliasMetadata?: AggregationAliasDetail[]): AggregationResult;
+    /**
+     * Document-style query API - returns single result or null
+     */
+    static queryOne<T extends BaseModel, P extends ProjectionSpec | undefined = undefined>(this: new (...args: any[]) => T, filter?: DocumentFilter, options?: Omit<QueryOptions, "limit" | "uniqueStartKey" | "direction"> & {
+        projection?: P;
+    }): Promise<QueryResult<T, P> | null>;
+    /**
+     * Document-style count API
+     */
+    static count(this: new (...args: any[]) => any, filter?: DocumentFilter, options?: Pick<QueryOptions, "documents">): Promise<number>;
+    static findAll<T extends BaseModel>(this: new (...args: any[]) => T): Promise<T[]>;
+    static findByUnique<T extends BaseModel>(this: typeof BaseModel & (new (...args: any[]) => T), constraintName: string, value: any | any[]): Promise<T | null>;
+    static upsertByUnique<T extends BaseModel>(this: typeof BaseModel & (new (...args: any[]) => T), constraintName: string, uniqueLookupValue: any | any[], dataToUpsert: Partial<Omit<InstanceType<new (...args: any[]) => T>, keyof BaseModel | "toJSON">> & {
+        id?: string;
+    }, options?: {
+        objectMustExist?: boolean;
+        objectMustNotExist?: boolean;
+        targetDocument?: string;
+    }): Promise<T>;
+    /**
+     * Execute a callback with automatic transaction handling for all modified models
+     */
+    static withTransaction<T>(callback: () => Promise<T> | T): Promise<T>;
+    /**
+     * Sets up deep observation on a nested YMap to sync field-level changes to the database
+     */
+    protected static setupNestedYMapObserver(recordId: string, recordYMap: Y.Map<any>): void;
+    /**
+     * Sets up deep observation on a nested YMap for a specific document to sync field-level changes to the database
+     */
+    protected static setupNestedYMapObserverForDocument(recordId: string, recordYMap: Y.Map<any>, docId: string, permissionHint: DocumentPermissionHint): void;
+}
+
+interface ResolvedUniqueConstraint {
+    name: string;
+    fields: string[];
+}
+interface ModelSchemaRuntimeShape {
+    class: typeof BaseModel;
+    options: ModelOptions;
+    fields: Map<string, FieldOptions>;
+    resolvedUniqueConstraints: ResolvedUniqueConstraint[];
+}
+interface DefinedModelSchema<TFields extends Record<string, FieldOptions> = Record<string, FieldOptions>> {
+    name: string;
+    fields: TFields;
+    options: ModelOptions;
+    runtimeShape?: ModelSchemaRuntimeShape;
+    buildRuntimeShape(modelClass: typeof BaseModel): ModelSchemaRuntimeShape;
+}
+
+/**
+ * TOML Schema Loader
+ *
+ * Parses a TOML schema file and returns an array of DefinedModelSchema
+ * objects.  Can be used in place of manual `defineModelSchema()` calls.
+ *
+ * TOML conventions:
+ *  - Property names are snake_case (auto_assign, max_count, …)
+ *  - Model names and field names are as-is (user-chosen)
+ *  - Relationships live under [models.*.relationships.*]
+ *  - Compound unique constraints are [[models.*.unique_constraints]]
+ */
+
+/**
+ * Parse a TOML string and return an array of DefinedModelSchema objects.
+ */
+declare function loadSchemaFromTomlString(tomlString: string): DefinedModelSchema[];
+
+/**
+ * Meta Sync — writes _meta_* YMaps into a YDoc.
+ *
+ * Each model with data in a YDoc gets a `_meta_{modelName}` YMap that
+ * describes the model's fields, constraints, and relationships.  This
+ * lets any language that can read a YDoc discover the schema without
+ * external configuration.
+ *
+ * Two modes:
+ *  1. **Schema-aware** — full schema known (from defineModelSchema / TOML).
+ *     Writes field metadata, constraints, and relationships.
+ *  2. **Infer-on-write** — no schema.  Infers types from record values.
+ */
+
+/**
+ * Infer a _meta_ type string from a JS runtime value.
+ */
+declare function inferFieldType(value: unknown): "string" | "number" | "boolean" | "stringset" | null;
+/**
+ * Register a named function default so metaSync can encode it.
+ * Called once per known default generator.
+ */
+declare function registerFunctionDefault(fn: Function, name: string): void;
+/**
+ * Clear the sync cache for a specific doc (or all docs).
+ * Useful for testing or when schema changes at runtime.
+ */
+declare function clearMetaSyncCache(yDoc?: Y.Doc): void;
+/**
+ * Sync full schema metadata into `_meta_{modelName}` inside a YDoc.
+ *
+ * Call this inside an existing `yDoc.transact()`.  Y.Map `.set()` on
+ * identical values is a CRDT no-op so there is no overhead after the
+ * first write.
+ *
+ * Skips the sync if this (yDoc, modelName) pair has already been synced
+ * in the current session.
+ */
+declare function syncModelMeta(yDoc: Y.Doc, modelName: string, schema: ModelSchemaRuntimeShape): void;
+/**
+ * Infer-on-write: when no schema is available, infer field types from
+ * the record data and write minimal _meta_.
+ *
+ * Call inside an existing `yDoc.transact()`.
+ */
+declare function syncInferredMeta(yDoc: Y.Doc, modelName: string, recordData: Record<string, any>): void;
+
+export { type AfterQueryContext, type AfterQueryResult, type AggregateRequest, type AggregateResponse, type AggregationOperation$1 as AggregationOperation, type AggregationOptions$1 as AggregationOptions, type AggregationResult$1 as AggregationResult, type BatchOperation, type BatchOperationResult, type BatchRequest, type BatchResponse, type BeforeDeleteContext, type BeforeQueryContext, type BeforeQueryResult, type BeforeSaveContext, type CountRequest, type CountResponse, type DatabaseDOConfig, type DatabaseDOHooks, type DeleteRequest, type DeleteResponse, type DiscoveredConstraint, type DiscoveredField, type DiscoveredModel, type DiscoveredRelationship, type DiscoveredSchema, type DocumentDOConfig, type DropIndexRequest, type DropIndexResponse, type DropUniqueConstraintRequest, type DropUniqueConstraintResponse, DurableObjectEngine, type DurableObjectEngineOptions, type DurableObjectId, type DurableObjectNamespace, type DurableObjectState, type DurableObjectStorage, type DurableObjectStub, type Env, type ErrorResponse, type GroupByField$1 as GroupByField, type HookContext, type HookResult, type IncrementRequest, type IncrementResponse, type IndexEntry, type IndexListResponse, JsonQueryTranslator, type JsonQueryTranslatorOptions, JsonSchemaDDL, type JsonSchemaOptions, type PatchRequest, type PatchResponse, type QueryRequest, type QueryResponse, type RegisterIndexRequest, type RegisterIndexResponse, type RegisterUniqueConstraintRequest, type RegisterUniqueConstraintResponse, type SaveRequest, type SaveResponse, type SchemaConstraintInfo, type SchemaFieldInfo, type SchemaModelInfo, type SchemaResponse, type SqlStorage, type SqlStorageCursor, type StringSetMembership$1 as StringSetMembership, type StringSetUpdateRequest, type StringSetUpdateResponse, type SyncIndexesRequest, type SyncIndexesResponse, type UniqueConstraintEntry, type UniqueConstraintListResponse, clearMetaSyncCache, createDatabaseDO, createDocumentDO, discoverModelNames, discoverSchema, handleRequest, inferFieldType, loadSchemaFromTomlString, registerFunctionDefault, schemaToToml, syncInferredMeta, syncModelMeta };