pomegranate-db 0.1.0

package/dist/expo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * PomegranateDB — Expo entry point.
+ *
+ * Convenience module that re-exports everything from the main
+ * package plus the Expo-specific driver.
+ *
+ * Usage:
+ *   import { Database, SQLiteAdapter, createExpoSQLiteDriver } from 'pomegranate-db/expo';
+ */
+export * from './index';
+export { createExpoSQLiteDriver } from './adapters/expo-sqlite';
+export type { ExpoSQLiteDriverConfig } from './adapters/expo-sqlite';

package/dist/expo.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * PomegranateDB — Expo entry point.
+ *
+ * Convenience module that re-exports everything from the main
+ * package plus the Expo-specific driver.
+ *
+ * Usage:
+ *   import { Database, SQLiteAdapter, createExpoSQLiteDriver } from 'pomegranate-db/expo';
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpoSQLiteDriver = void 0;
+// Re-export everything from main package
+__exportStar(require("./index"), exports);
+// Export Expo-specific driver
+var expo_sqlite_1 = require("./adapters/expo-sqlite");
+Object.defineProperty(exports, "createExpoSQLiteDriver", { enumerable: true, get: function () { return expo_sqlite_1.createExpoSQLiteDriver; } });
+//# sourceMappingURL=expo.js.map

package/dist/hooks/index.d.ts

@@ -0,0 +1,115 @@
+/**
+ * React hooks for PomegranateDB.
+ *
+ * Provides reactive hooks that subscribe to database observables
+ * and re-render components when data changes.
+ */
+import type { Collection } from '../collection/Collection';
+import type { Model } from '../model/Model';
+import type { QueryBuilder } from '../query/QueryBuilder';
+import type { Observable } from '../observable/Subject';
+/**
+ * Subscribe to any Observable and return its latest value.
+ */
+export declare function useObservable<T>(observable: Observable<T> | null | undefined, initialValue: T): T;
+/**
+ * Execute a query and subscribe to live updates.
+ * Re-runs the query whenever the collection changes.
+ */
+export declare function useLiveQuery<M extends Model>(collection: Collection<M> | null | undefined, buildQuery?: (qb: QueryBuilder) => void, deps?: unknown[]): {
+    results: M[];
+    isLoading: boolean;
+};
+/**
+ * Observe a single record by ID.
+ * Returns null if not found, undefined while loading.
+ */
+export declare function useById<M extends Model>(collection: Collection<M> | null | undefined, id: string | null | undefined): {
+    record: M | null | undefined;
+    isLoading: boolean;
+};
+/**
+ * Observe a specific field on a record.
+ * Only re-renders when that field changes.
+ */
+export declare function useField<M extends Model>(record: M | null | undefined, fieldName: string): {
+    value: unknown;
+    isLoading: boolean;
+};
+export interface UseSearchOptions {
+    term: string;
+    fields: string[];
+    limit?: number;
+    offset?: number;
+    orderBy?: Record<string, 'asc' | 'desc'>;
+    extend?: (qb: QueryBuilder) => void;
+}
+export interface UseSearchResult<M extends Model> {
+    results: M[];
+    total: number;
+    isLoading: boolean;
+    hasMore: boolean;
+}
+/**
+ * Full-text search with pagination and live results.
+ */
+export declare function useSearch<M extends Model>(collection: Collection<M> | null | undefined, options: UseSearchOptions, deps?: unknown[]): UseSearchResult<M>;
+/**
+ * Observe the count of records matching a query.
+ */
+export declare function useCount<M extends Model>(collection: Collection<M> | null | undefined, buildQuery?: (qb: QueryBuilder) => void, deps?: unknown[]): {
+    count: number;
+    isLoading: boolean;
+};
+import { type ReactNode } from 'react';
+import { Database } from '../database/Database';
+import type { DatabaseConfig } from '../database/Database';
+/**
+ * Provide a Database instance to the React tree.
+ */
+export declare const DatabaseProvider: import("react").Provider<Database | null>;
+/**
+ * Get the Database instance from context.
+ */
+export declare function useDatabase(): Database;
+/**
+ * Get a collection by model class from context.
+ */
+export declare function useCollection<M extends Model>(modelClass: {
+    schema: {
+        table: string;
+    };
+}): Collection<M>;
+/**
+ * Props for DatabaseSuspenseProvider.
+ */
+export interface DatabaseSuspenseProviderProps extends DatabaseConfig {
+    children: ReactNode;
+}
+/**
+ * A Suspense-compatible database provider.
+ *
+ * Creates and initializes a Database, suspending the component tree until
+ * the database is ready. Wrap with `<Suspense fallback={...}>` to show
+ * a loading state.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'react';
+ * import { DatabaseSuspenseProvider, useLiveQuery } from 'pomegranate-db';
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<Text>Preparing database...</Text>}>
+ *       <DatabaseSuspenseProvider
+ *         adapter={new LokiAdapter({ databaseName: 'myapp' })}
+ *         models={[Post, Comment]}
+ *       >
+ *         <MyApp />
+ *       </DatabaseSuspenseProvider>
+ *     </Suspense>
+ *   );
+ * }
+ * ```
+ */
+export declare function DatabaseSuspenseProvider({ children, ...config }: DatabaseSuspenseProviderProps): ReactNode;

package/dist/hooks/index.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * React hooks for PomegranateDB.
+ *
+ * Provides reactive hooks that subscribe to database observables
+ * and re-render components when data changes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseProvider = void 0;
+exports.useObservable = useObservable;
+exports.useLiveQuery = useLiveQuery;
+exports.useById = useById;
+exports.useField = useField;
+exports.useSearch = useSearch;
+exports.useCount = useCount;
+exports.useDatabase = useDatabase;
+exports.useCollection = useCollection;
+exports.DatabaseSuspenseProvider = DatabaseSuspenseProvider;
+const react_1 = require("react");
+// ─── useObservable ─────────────────────────────────────────────────────────
+/**
+ * Subscribe to any Observable and return its latest value.
+ */
+function useObservable(observable, initialValue) {
+    const [value, setValue] = (0, react_1.useState)(initialValue);
+    (0, react_1.useEffect)(() => {
+        if (!observable)
+            return;
+        const unsub = observable.subscribe((v) => {
+            setValue(v);
+        });
+        return unsub;
+    }, [observable]);
+    return value;
+}
+// ─── useLiveQuery ──────────────────────────────────────────────────────────
+/**
+ * Execute a query and subscribe to live updates.
+ * Re-runs the query whenever the collection changes.
+ */
+function useLiveQuery(collection, buildQuery, deps = []) {
+    const [results, setResults] = (0, react_1.useState)([]);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        if (!collection)
+            return;
+        setIsLoading(true);
+        const qb = buildQuery ? collection.query(buildQuery) : collection.query();
+        const observable = collection.observeQuery(qb);
+        const unsub = observable.subscribe((records) => {
+            setResults(records);
+            setIsLoading(false);
+        });
+        return unsub;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [collection, ...deps]);
+    return { results, isLoading };
+}
+// ─── useById ──────────────────────────────────────────────────────────────
+/**
+ * Observe a single record by ID.
+ * Returns null if not found, undefined while loading.
+ */
+function useById(collection, id) {
+    const [record, setRecord] = (0, react_1.useState)(undefined);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        if (!collection || !id) {
+            setRecord(null);
+            setIsLoading(false);
+            return;
+        }
+        setIsLoading(true);
+        const observable = collection.observeById(id);
+        const unsub = observable.subscribe((r) => {
+            setRecord(r);
+            setIsLoading(false);
+        });
+        return unsub;
+    }, [collection, id]);
+    return { record, isLoading };
+}
+// ─── useField ─────────────────────────────────────────────────────────────
+/**
+ * Observe a specific field on a record.
+ * Only re-renders when that field changes.
+ */
+function useField(record, fieldName) {
+    const [value, setValue] = (0, react_1.useState)(undefined);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        if (!record) {
+            setValue(undefined);
+            setIsLoading(false);
+            return;
+        }
+        // Get initial value
+        try {
+            setValue(record.getField(fieldName));
+            setIsLoading(false);
+        }
+        catch {
+            setIsLoading(false);
+        }
+        const observable = record.observeField(fieldName);
+        const unsub = observable.subscribe((v) => {
+            setValue(v);
+            setIsLoading(false);
+        });
+        return unsub;
+    }, [record, fieldName]);
+    return { value, isLoading };
+}
+/**
+ * Full-text search with pagination and live results.
+ */
+function useSearch(collection, options, deps = []) {
+    const [results, setResults] = (0, react_1.useState)([]);
+    const [total, setTotal] = (0, react_1.useState)(0);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    const limit = options.limit ?? 50;
+    const offset = options.offset ?? 0;
+    (0, react_1.useEffect)(() => {
+        if (!collection || !options.term) {
+            setResults([]);
+            setTotal(0);
+            setIsLoading(false);
+            return;
+        }
+        setIsLoading(true);
+        let cancelled = false;
+        const doSearch = async () => {
+            try {
+                const result = await collection.search({
+                    term: options.term,
+                    fields: options.fields,
+                    limit,
+                    offset,
+                    orderBy: options.orderBy,
+                    extend: options.extend,
+                });
+                if (!cancelled) {
+                    setResults(result.records);
+                    setTotal(result.total);
+                    setIsLoading(false);
+                }
+            }
+            catch {
+                if (!cancelled) {
+                    setIsLoading(false);
+                }
+            }
+        };
+        doSearch();
+        // Re-run search when collection changes
+        const unsub = collection.changes$.subscribe(() => {
+            doSearch();
+        });
+        return () => {
+            cancelled = true;
+            unsub();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [collection, options.term, options.fields.join(','), limit, offset, ...deps]);
+    const hasMore = offset + limit < total;
+    return { results, total, isLoading, hasMore };
+}
+// ─── useCount ─────────────────────────────────────────────────────────────
+/**
+ * Observe the count of records matching a query.
+ */
+function useCount(collection, buildQuery, deps = []) {
+    const [count, setCount] = (0, react_1.useState)(0);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        if (!collection)
+            return;
+        setIsLoading(true);
+        const qb = buildQuery ? collection.query(buildQuery) : collection.query();
+        const observable = collection.observeCount(qb);
+        const unsub = observable.subscribe((c) => {
+            setCount(c);
+            setIsLoading(false);
+        });
+        return unsub;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [collection, ...deps]);
+    return { count, isLoading };
+}
+// ─── DatabaseProvider ──────────────────────────────────────────────────────
+const react_2 = require("react");
+const Database_1 = require("../database/Database");
+const DatabaseContext = (0, react_2.createContext)(null);
+/**
+ * Provide a Database instance to the React tree.
+ */
+exports.DatabaseProvider = DatabaseContext.Provider;
+/**
+ * Get the Database instance from context.
+ */
+function useDatabase() {
+    const db = (0, react_2.useContext)(DatabaseContext);
+    if (!db) {
+        throw new Error('useDatabase() must be used within a <DatabaseProvider>. ' +
+            'Wrap your app with <DatabaseProvider value={db}>.');
+    }
+    return db;
+}
+/**
+ * Get a collection by model class from context.
+ */
+function useCollection(modelClass) {
+    const db = useDatabase();
+    return db.collection(modelClass.schema.table);
+}
+/**
+ * Create a Suspense-compatible resource that initializes a Database.
+ * Follows the React Suspense "throw a promise" contract:
+ * - First call: throws a promise (React suspends)
+ * - After resolved: returns the Database
+ * - On error: throws the error (React error boundary catches it)
+ */
+function createDatabaseResource(config) {
+    const db = new Database_1.Database(config);
+    let status = {
+        state: 'pending',
+        promise: db.initialize().then(() => {
+            status = { state: 'resolved', value: db };
+        }, (error) => {
+            status = { state: 'rejected', error: error };
+        }),
+    };
+    return {
+        read() {
+            switch (status.state) {
+                case 'pending':
+                    throw status.promise;
+                case 'rejected':
+                    throw status.error;
+                case 'resolved':
+                    return status.value;
+            }
+        },
+    };
+}
+// Cache to avoid re-creating the resource on re-render
+const resourceCache = new WeakMap();
+/**
+ * A Suspense-compatible database provider.
+ *
+ * Creates and initializes a Database, suspending the component tree until
+ * the database is ready. Wrap with `<Suspense fallback={...}>` to show
+ * a loading state.
+ *
+ * @example
+ * ```tsx
+ * import { Suspense } from 'react';
+ * import { DatabaseSuspenseProvider, useLiveQuery } from 'pomegranate-db';
+ *
+ * function App() {
+ *   return (
+ *     <Suspense fallback={<Text>Preparing database...</Text>}>
+ *       <DatabaseSuspenseProvider
+ *         adapter={new LokiAdapter({ databaseName: 'myapp' })}
+ *         models={[Post, Comment]}
+ *       >
+ *         <MyApp />
+ *       </DatabaseSuspenseProvider>
+ *     </Suspense>
+ *   );
+ * }
+ * ```
+ */
+function DatabaseSuspenseProvider({ children, ...config }) {
+    // Use the adapter as cache key — stable across re-renders
+    const cacheKey = config.adapter;
+    let resource = resourceCache.get(cacheKey);
+    if (!resource) {
+        resource = createDatabaseResource(config);
+        resourceCache.set(cacheKey, resource);
+    }
+    const db = resource.read(); // Suspends if not ready
+    return (0, react_2.createElement)(exports.DatabaseProvider, { value: db }, children);
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PomegranateDB — main entry point.
+ *
+ * Reactive offline-first database with sync support.
+ */
+export { m } from './schema';
+export type { ColumnType, ColumnDescriptor, TextColumn, NumberColumn, BooleanColumn, DateColumn, BelongsToDescriptor, HasManyDescriptor, RelationDescriptor, FieldDescriptor, SchemaFields, ModelSchema, ResolvedColumn, ResolvedRelation, DatabaseSchema, TableSchema, SyncStatus, RawRecord, InferCreatePatch, InferUpdatePatch, InferRecord, } from './schema';
+export { Model } from './model';
+export type { ModelStatic } from './model';
+export { Collection } from './collection';
+export type { CollectionChangeType, CollectionChange } from './collection';
+export { Database } from './database';
+export type { DatabaseConfig, DatabaseEvent } from './database';
+export { QueryBuilder, query } from './query';
+export type { QueryDescriptor, SearchDescriptor, ComparisonOperator, SortOrder, Condition, WhereClause, OrderByClause, BatchOperation, } from './query';
+export { SQLiteAdapter } from './adapters';
+export type { SQLiteAdapterConfig, SQLiteDriver } from './adapters';
+export { LokiAdapter, SynchronousWorker } from './adapters';
+export type { LokiAdapterConfig, WorkerInterface } from './adapters';
+export { createExpoSQLiteDriver } from './adapters';
+export type { ExpoSQLiteDriverConfig } from './adapters';
+export type { StorageAdapter, EncryptionConfig, Migration, MigrationStep } from './adapters';
+export { performSync } from './sync';
+export type { SyncConfig, SyncPullResult, SyncPushPayload, SyncTableChanges, SyncTableChangeSet, SyncState, SyncLog, } from './sync';
+export { EncryptionManager, EncryptingAdapter } from './encryption';
+export { Subject, BehaviorSubject, SharedObservable } from './observable';
+export type { Observable, Listener, Unsubscribe } from './observable';
+export { useObservable, useLiveQuery, useById, useField, useSearch, useCount, useDatabase, useCollection, DatabaseProvider, DatabaseSuspenseProvider, } from './hooks';
+export type { UseSearchOptions, UseSearchResult, DatabaseSuspenseProviderProps } from './hooks';

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * PomegranateDB — main entry point.
+ *
+ * Reactive offline-first database with sync support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseSuspenseProvider = exports.DatabaseProvider = exports.useCollection = exports.useDatabase = exports.useCount = exports.useSearch = exports.useField = exports.useById = exports.useLiveQuery = exports.useObservable = exports.SharedObservable = exports.BehaviorSubject = exports.Subject = exports.EncryptingAdapter = exports.EncryptionManager = exports.performSync = exports.createExpoSQLiteDriver = exports.SynchronousWorker = exports.LokiAdapter = exports.SQLiteAdapter = exports.query = exports.QueryBuilder = exports.Database = exports.Collection = exports.Model = exports.m = void 0;
+// ─── Schema ────────────────────────────────────────────────────────────────
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "m", { enumerable: true, get: function () { return schema_1.m; } });
+// ─── Model ─────────────────────────────────────────────────────────────────
+var model_1 = require("./model");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_1.Model; } });
+// ─── Collection ────────────────────────────────────────────────────────────
+var collection_1 = require("./collection");
+Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return collection_1.Collection; } });
+// ─── Database ──────────────────────────────────────────────────────────────
+var database_1 = require("./database");
+Object.defineProperty(exports, "Database", { enumerable: true, get: function () { return database_1.Database; } });
+// ─── Query ─────────────────────────────────────────────────────────────────
+var query_1 = require("./query");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return query_1.QueryBuilder; } });
+Object.defineProperty(exports, "query", { enumerable: true, get: function () { return query_1.query; } });
+// ─── Adapters ──────────────────────────────────────────────────────────────
+var adapters_1 = require("./adapters");
+Object.defineProperty(exports, "SQLiteAdapter", { enumerable: true, get: function () { return adapters_1.SQLiteAdapter; } });
+var adapters_2 = require("./adapters");
+Object.defineProperty(exports, "LokiAdapter", { enumerable: true, get: function () { return adapters_2.LokiAdapter; } });
+Object.defineProperty(exports, "SynchronousWorker", { enumerable: true, get: function () { return adapters_2.SynchronousWorker; } });
+var adapters_3 = require("./adapters");
+Object.defineProperty(exports, "createExpoSQLiteDriver", { enumerable: true, get: function () { return adapters_3.createExpoSQLiteDriver; } });
+// ─── Sync ──────────────────────────────────────────────────────────────────
+var sync_1 = require("./sync");
+Object.defineProperty(exports, "performSync", { enumerable: true, get: function () { return sync_1.performSync; } });
+// ─── Encryption ────────────────────────────────────────────────────────────
+var encryption_1 = require("./encryption");
+Object.defineProperty(exports, "EncryptionManager", { enumerable: true, get: function () { return encryption_1.EncryptionManager; } });
+Object.defineProperty(exports, "EncryptingAdapter", { enumerable: true, get: function () { return encryption_1.EncryptingAdapter; } });
+// ─── Observable ────────────────────────────────────────────────────────────
+var observable_1 = require("./observable");
+Object.defineProperty(exports, "Subject", { enumerable: true, get: function () { return observable_1.Subject; } });
+Object.defineProperty(exports, "BehaviorSubject", { enumerable: true, get: function () { return observable_1.BehaviorSubject; } });
+Object.defineProperty(exports, "SharedObservable", { enumerable: true, get: function () { return observable_1.SharedObservable; } });
+// ─── Hooks (React) ─────────────────────────────────────────────────────────
+var hooks_1 = require("./hooks");
+Object.defineProperty(exports, "useObservable", { enumerable: true, get: function () { return hooks_1.useObservable; } });
+Object.defineProperty(exports, "useLiveQuery", { enumerable: true, get: function () { return hooks_1.useLiveQuery; } });
+Object.defineProperty(exports, "useById", { enumerable: true, get: function () { return hooks_1.useById; } });
+Object.defineProperty(exports, "useField", { enumerable: true, get: function () { return hooks_1.useField; } });
+Object.defineProperty(exports, "useSearch", { enumerable: true, get: function () { return hooks_1.useSearch; } });
+Object.defineProperty(exports, "useCount", { enumerable: true, get: function () { return hooks_1.useCount; } });
+Object.defineProperty(exports, "useDatabase", { enumerable: true, get: function () { return hooks_1.useDatabase; } });
+Object.defineProperty(exports, "useCollection", { enumerable: true, get: function () { return hooks_1.useCollection; } });
+Object.defineProperty(exports, "DatabaseProvider", { enumerable: true, get: function () { return hooks_1.DatabaseProvider; } });
+Object.defineProperty(exports, "DatabaseSuspenseProvider", { enumerable: true, get: function () { return hooks_1.DatabaseSuspenseProvider; } });
+//# sourceMappingURL=index.js.map

package/dist/model/Model.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Model base class.
+ *
+ * Each model instance represents a single database record.
+ * Models are schema-first: the schema defines columns, relations,
+ * and the TypeScript types are inferred from it.
+ *
+ * Usage:
+ *   class Post extends Model<typeof PostSchema> {
+ *     static schema = PostSchema;
+ *
+ *     publish = this.writer(async () => {
+ *       await this.update({ status: 'published' });
+ *     });
+ *   }
+ */
+import type { ModelSchema, RawRecord, SyncStatus } from '../schema/types';
+import type { Observable } from '../observable/Subject';
+/** Minimal interface for what a Collection provides to a Model */
+export interface ModelCollectionRef {
+    readonly table: string;
+    _update(id: string, raw: Partial<RawRecord>): Promise<void>;
+    _delete(id: string): Promise<void>;
+    _destroyPermanently(id: string): Promise<void>;
+    _getDatabase(): ModelDatabaseRef;
+}
+/** Minimal interface for what a Database provides */
+export interface ModelDatabaseRef {
+    _ensureInWriter(action: string): void;
+    _batch(operations: Array<{
+        type: string;
+        table: string;
+        rawRecord?: Record<string, unknown>;
+        id?: string;
+    }>): Promise<void>;
+}
+export type ModelStatic<S extends ModelSchema = ModelSchema> = {
+    new (collection: ModelCollectionRef, raw: RawRecord): Model<S>;
+    schema: S;
+};
+export declare class Model<S extends ModelSchema = ModelSchema> {
+    #private;
+    static schema: ModelSchema;
+    /** The record id */
+    readonly id: string;
+    /** Reference back to the owning collection */
+    readonly collection: ModelCollectionRef;
+    constructor(collection: ModelCollectionRef, raw: RawRecord);
+    /** Get the current raw record */
+    get _rawRecord(): RawRecord;
+    /** Sync status of this record */
+    get syncStatus(): SyncStatus;
+    /** Changed fields (comma-separated) */
+    get changedFields(): string;
+    /**
+     * Get a field value, converting from raw storage form.
+     */
+    getField(fieldName: string): unknown;
+    /**
+     * Set field value(s) on the raw record (does NOT persist — internal use).
+     */
+    _setRaw(updates: Partial<RawRecord>): void;
+    /** Observe changes to this record */
+    observe(): Observable<this>;
+    /** Observe a specific field */
+    observeField(fieldName: string): Observable<unknown>;
+    /**
+     * Update this record with a patch of field values.
+     * Must be called inside `db.write()`.
+     */
+    update(patch: Record<string, unknown>): Promise<void>;
+    /**
+     * Mark this record as deleted (soft delete for sync).
+     * Must be called inside `db.write()`.
+     */
+    markAsDeleted(): Promise<void>;
+    /**
+     * Permanently destroy this record.
+     * Must be called inside `db.write()`.
+     */
+    destroyPermanently(): Promise<void>;
+    /**
+     * Create a bound writer method.
+     * The returned function, when called, will run inside the current write transaction.
+     */
+    writer<Args extends unknown[], R>(fn: (...args: Args) => Promise<R>): (...args: Args) => Promise<R>;
+    /**
+     * Return raw values suitable for the sync push payload.
+     */
+    toPushPayload(): Record<string, unknown>;
+}
+export declare function createRawRecord(schema: ModelSchema, patch: Record<string, unknown>, id?: string): RawRecord;