local-lite 0.0.0-stage → 0.0.1

package/dist/core/sync-worker.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncWorker = void 0;
+const conflict_js_1 = require("./conflict.js");
+const index_js_1 = require("../adapters/network/index.js");
+const outbox_store_js_1 = require("./outbox-store.js");
+const meta_store_js_1 = require("./meta-store.js");
+const table_manager_js_1 = require("./table-manager.js");
+const logger_js_1 = require("../utils/logger.js");
+class SyncWorker {
+    db;
+    remote;
+    events;
+    network;
+    conflictResolver;
+    primaryKey;
+    autoSchema;
+    schemaManager;
+    logger;
+    retryConfig;
+    pushIntervalMs;
+    pullIntervalMs;
+    maxRetries;
+    pushIntervalTimer;
+    pullIntervalTimer;
+    pushDebounceTimer;
+    networkUnsubscribe;
+    isPushing = false;
+    isPulling = false;
+    lastPulledTimestamp = 0;
+    cursorLoaded = false;
+    deltaQueue = Promise.resolve();
+    constructor(db, remote, events, options = {}) {
+        this.db = db;
+        this.remote = remote;
+        this.events = events;
+        this.network = options.network ?? new index_js_1.DefaultNetworkStatusProvider();
+        this.conflictResolver = (0, conflict_js_1.getConflictResolver)(options.conflictResolver ?? 'last-write-wins');
+        this.primaryKey = options.primaryKey ?? 'id';
+        this.autoSchema = options.autoSchema ?? false;
+        this.schemaManager = options.schemaManager;
+        this.pushIntervalMs = options.pushIntervalMs ?? 5000;
+        this.pullIntervalMs = options.pullIntervalMs ?? 10000;
+        // Configure logger
+        if (options.logger instanceof logger_js_1.SyncLogger) {
+            this.logger = options.logger;
+        }
+        else if (typeof options.logger === 'boolean') {
+            this.logger = new logger_js_1.SyncLogger({ enabled: options.logger, level: options.logLevel });
+        }
+        else if (options.logger && typeof options.logger === 'object') {
+            this.logger = new logger_js_1.SyncLogger({ customLogger: options.logger, level: options.logLevel });
+        }
+        else {
+            this.logger = options.logLevel ? new logger_js_1.SyncLogger({ level: options.logLevel }) : logger_js_1.defaultLogger;
+        }
+        // Configure retries & backoff
+        const r = options.retry;
+        if (typeof r === 'number') {
+            this.retryConfig = {
+                maxRetries: r,
+                initialDelayMs: 1000,
+                backoffMultiplier: 1.5,
+                maxDelayMs: 30000,
+            };
+        }
+        else if (typeof r === 'object' && r !== null) {
+            this.retryConfig = {
+                maxRetries: r.maxRetries ?? options.maxRetries ?? 5,
+                initialDelayMs: r.initialDelayMs ?? 1000,
+                backoffMultiplier: r.backoffMultiplier ?? 1.5,
+                maxDelayMs: r.maxDelayMs ?? 30000,
+                shouldRetry: r.shouldRetry,
+            };
+        }
+        else {
+            this.retryConfig = {
+                maxRetries: options.maxRetries ?? 5,
+                initialDelayMs: 1000,
+                backoffMultiplier: 1.5,
+                maxDelayMs: 30000,
+            };
+        }
+        this.maxRetries = this.retryConfig.maxRetries ?? 5;
+    }
+    /**
+     * Starts background interval push/pull loops and listens for network & realtime updates.
+     */
+    start() {
+        this.stop();
+        this.pushIntervalTimer = setInterval(() => this.pushLocalChanges(), this.pushIntervalMs);
+        this.pullIntervalTimer = setInterval(() => this.pullRemoteChanges(), this.pullIntervalMs);
+        // Subscribe to live remote changes
+        this.remote.subscribeToLiveChanges((deltas) => {
+            this.applyDeltasLocally(deltas).catch((err) => {
+                this.logger.error('Error applying live remote deltas:', err);
+            });
+        });
+        // Subscribe to network connectivity changes
+        this.networkUnsubscribe = this.network.subscribe((online) => {
+            if (online) {
+                this.schedulePush(0);
+                this.pullRemoteChanges().catch((err) => {
+                    this.logger.error('Error pulling changes on reconnect:', err);
+                });
+            }
+        });
+        // Initial pull
+        this.pullRemoteChanges().catch((err) => {
+            this.logger.error('Initial pull failed:', err);
+        });
+    }
+    /**
+     * Stops all active intervals, timers, and listeners.
+     */
+    stop() {
+        if (this.pushIntervalTimer) {
+            clearInterval(this.pushIntervalTimer);
+            this.pushIntervalTimer = undefined;
+        }
+        if (this.pullIntervalTimer) {
+            clearInterval(this.pullIntervalTimer);
+            this.pullIntervalTimer = undefined;
+        }
+        if (this.pushDebounceTimer) {
+            clearTimeout(this.pushDebounceTimer);
+            this.pushDebounceTimer = undefined;
+        }
+        if (this.networkUnsubscribe) {
+            this.networkUnsubscribe();
+            this.networkUnsubscribe = undefined;
+        }
+    }
+    /**
+     * Schedules an immediate push with a short debounce.
+     */
+    schedulePush(delayMs = 50) {
+        if (this.pushDebounceTimer) {
+            clearTimeout(this.pushDebounceTimer);
+        }
+        this.pushDebounceTimer = setTimeout(() => {
+            this.pushDebounceTimer = undefined;
+            this.pushLocalChanges().catch((err) => {
+                this.logger.error('Debounced push failed:', err);
+            });
+        }, delayMs);
+    }
+    async isOnline() {
+        try {
+            return await Promise.resolve(this.network.isOnline());
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Pushes pending outbox records to the remote database.
+     */
+    async pushLocalChanges() {
+        if (this.isPushing)
+            return;
+        if (!(await this.isOnline()))
+            return;
+        this.isPushing = true;
+        let pendingRecords = [];
+        try {
+            pendingRecords = await outbox_store_js_1.OutboxStore.getPending(this.db, this.maxRetries);
+            if (pendingRecords.length === 0) {
+                return;
+            }
+            const operations = pendingRecords.map((r) => ({
+                id: r.id,
+                tableName: r.tableName,
+                rowId: r.rowId,
+                operation: r.operation,
+                payload: r.payload,
+                timestamp: r.timestamp,
+            }));
+            const recordIds = operations.map((o) => o.id);
+            // Mark records as PROCESSING
+            await outbox_store_js_1.OutboxStore.markProcessing(this.db, recordIds);
+            const success = await this.remote.pushChanges(operations);
+            if (success) {
+                // Successful push: delete rows from outbox
+                await outbox_store_js_1.OutboxStore.deleteCompleted(this.db, recordIds);
+                this.events.emit('sync_outbox', { operation: 'DELETE', rowId: 'batch' });
+            }
+            else {
+                await this.handlePushFailure(pendingRecords, 'Remote push returned false');
+            }
+        }
+        catch (error) {
+            this.logger.error('Sync Engine Outbox Push Error:', error);
+            if (pendingRecords.length > 0) {
+                await this.handlePushFailure(pendingRecords, error?.message || String(error), error);
+            }
+        }
+        finally {
+            this.isPushing = false;
+        }
+    }
+    async handlePushFailure(records, errorMessage, errorObj) {
+        try {
+            const recordIds = records.map((r) => r.id);
+            await outbox_store_js_1.OutboxStore.markFailed(this.db, recordIds, errorMessage);
+            this.events.emit('sync_outbox', { operation: 'UPDATE', rowId: 'batch' });
+            // If custom shouldRetry filter specifies an operation should NOT be retried, mark it FAILED permanently
+            if (this.retryConfig.shouldRetry && errorObj) {
+                for (const rec of records) {
+                    if (!this.retryConfig.shouldRetry(errorObj, rec)) {
+                        await outbox_store_js_1.OutboxStore.markFailed(this.db, [rec.id], `Non-retryable error: ${errorMessage}`);
+                    }
+                }
+            }
+            // Schedule next retry with exponential backoff
+            const currentRetry = Math.max(...records.map((r) => r.retryCount || 0));
+            const isInfinite = !Number.isFinite(this.maxRetries) || this.maxRetries === -1;
+            if (isInfinite || currentRetry < this.maxRetries) {
+                const backoffDelay = Math.min((this.retryConfig.initialDelayMs || 1000) *
+                    Math.pow(this.retryConfig.backoffMultiplier || 1.5, currentRetry), this.retryConfig.maxDelayMs || 30000);
+                this.schedulePush(backoffDelay);
+            }
+        }
+        catch (err) {
+            this.logger.error('Failed to update outbox failure status:', err);
+        }
+    }
+    /**
+     * Pulls delta changes from the remote backend since lastPulledTimestamp.
+     */
+    async pullRemoteChanges() {
+        if (this.isPulling)
+            return;
+        if (!(await this.isOnline()))
+            return;
+        this.isPulling = true;
+        try {
+            if (!this.cursorLoaded) {
+                this.lastPulledTimestamp = await meta_store_js_1.MetaStore.getLastSyncedAt(this.db);
+                this.cursorLoaded = true;
+            }
+            const deltas = await this.remote.fetchChanges(this.lastPulledTimestamp);
+            if (deltas) {
+                await this.applyDeltasLocally(deltas);
+            }
+        }
+        catch (error) {
+            this.logger.error('Sync Engine Delta Pull Error:', error);
+        }
+        finally {
+            this.isPulling = false;
+        }
+    }
+    /**
+     * Applies incoming server delta changes to local tables with conflict resolution.
+     * Serializes execution in a queue to prevent concurrent SQLite transactions.
+     */
+    async applyDeltasLocally(deltas) {
+        const task = async () => {
+            await this.processDeltasLocally(deltas);
+        };
+        const next = this.deltaQueue.then(task, task);
+        this.deltaQueue = next.catch(() => { });
+        return await next;
+    }
+    async processDeltasLocally(deltas) {
+        if (!deltas.changes || deltas.changes.length === 0) {
+            if (deltas.timestamp && deltas.timestamp > this.lastPulledTimestamp) {
+                this.lastPulledTimestamp = deltas.timestamp;
+                await meta_store_js_1.MetaStore.setLastSyncedAt(this.db, this.lastPulledTimestamp);
+            }
+            return;
+        }
+        await this.db.transaction(async (tx) => {
+            for (const change of deltas.changes) {
+                // 1. Check for pending local mutations for this (table_name, row_id)
+                const localPendingRecord = await outbox_store_js_1.OutboxStore.findPendingByRow(tx, change.tableName, change.rowId);
+                // 2. Query current local row if it exists
+                const localRow = await table_manager_js_1.TableManager.fetchRow(tx, change.tableName, change.rowId, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
+                // 3. Conflict resolution if there is a pending local change
+                if (localPendingRecord) {
+                    const resolution = await Promise.resolve(this.conflictResolver({
+                        tableName: change.tableName,
+                        rowId: change.rowId,
+                        remoteChange: change,
+                        localOutboxRecord: localPendingRecord,
+                        localRow,
+                    }));
+                    if (resolution === 'keep-local') {
+                        // Local offline change takes precedence
+                        continue;
+                    }
+                    if (resolution === 'apply-remote') {
+                        // Remote change wins: remove the superseded local pending outbox mutation
+                        await outbox_store_js_1.OutboxStore.deleteRecord(tx, localPendingRecord.id);
+                    }
+                    else if (typeof resolution === 'object' && resolution.mergePayload) {
+                        // Merge scenario
+                        change.payload = resolution.mergePayload;
+                        await outbox_store_js_1.OutboxStore.updatePayload(tx, localPendingRecord.id, resolution.mergePayload);
+                    }
+                }
+                // 4. Apply remote change to local database
+                await table_manager_js_1.TableManager.applyMutation(tx, change.tableName, change.rowId, change.operation, change.payload, this.primaryKey, { autoSchema: this.autoSchema, schemaManager: this.schemaManager });
+                // 5. Emit table change event to notify reactive listeners
+                this.events.emit(change.tableName, {
+                    operation: change.operation,
+                    rowId: change.rowId,
+                    payload: change.payload,
+                    source: 'remote',
+                });
+            }
+            // Persist sync cursor atomically within the same transaction as delta writes
+            if (deltas.timestamp && deltas.timestamp > this.lastPulledTimestamp) {
+                await meta_store_js_1.MetaStore.setLastSyncedAt(tx, deltas.timestamp);
+            }
+        });
+        if (deltas.timestamp) {
+            this.lastPulledTimestamp = Math.max(this.lastPulledTimestamp, deltas.timestamp);
+        }
+    }
+    async getLastPulledTimestamp() {
+        if (!this.cursorLoaded) {
+            this.lastPulledTimestamp = await meta_store_js_1.MetaStore.getLastSyncedAt(this.db);
+            this.cursorLoaded = true;
+        }
+        return this.lastPulledTimestamp;
+    }
+    async resetSyncCursor() {
+        await meta_store_js_1.MetaStore.clearLastSyncedAt(this.db);
+        this.lastPulledTimestamp = 0;
+        this.cursorLoaded = true;
+    }
+}
+exports.SyncWorker = SyncWorker;

package/dist/core/table-manager.d.ts

@@ -0,0 +1,19 @@
+import { LocalTransaction } from '../adapters/local/index.js';
+import { SyncOp } from './types.js';
+import { SchemaManager } from './schema-manager.js';
+export interface TableMutationOptions {
+    autoSchema?: boolean;
+    schemaManager?: SchemaManager;
+}
+export declare class TableManager {
+    /**
+     * Applies an insert, update, or delete mutation on a local data table.
+     * If an INSERT is specified but the row already exists, it gracefully executes an UPDATE.
+     * If an UPDATE is specified but the row does not exist, it inserts it.
+     */
+    static applyMutation(tx: LocalTransaction, tableName: string, rowId: string, operation: SyncOp, payload: Record<string, any> | null, primaryKey?: string, options?: TableMutationOptions): Promise<void>;
+    /**
+     * Fetches an existing row from a local table by primary key.
+     */
+    static fetchRow(tx: LocalTransaction, tableName: string, rowId: string, primaryKey?: string, options?: TableMutationOptions): Promise<Record<string, any> | null>;
+}

package/dist/core/table-manager.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableManager = void 0;
+const sql_js_1 = require("../utils/sql.js");
+const schema_manager_js_1 = require("./schema-manager.js");
+const defaultSchemaManager = new schema_manager_js_1.SchemaManager();
+class TableManager {
+    /**
+     * Applies an insert, update, or delete mutation on a local data table.
+     * If an INSERT is specified but the row already exists, it gracefully executes an UPDATE.
+     * If an UPDATE is specified but the row does not exist, it inserts it.
+     */
+    static async applyMutation(tx, tableName, rowId, operation, payload, primaryKey = 'id', options) {
+        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+        const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
+        const sm = options?.schemaManager ?? defaultSchemaManager;
+        if (options?.autoSchema) {
+            await sm.ensureTable(tx, tableName, primaryKey);
+        }
+        if (operation === 'DELETE') {
+            await tx.execute(`DELETE FROM ${safeTable} WHERE ${safePk} = ?`, [rowId]);
+            return;
+        }
+        let rowData;
+        if (options?.autoSchema) {
+            const formatted = await sm.ensureColumns(tx, tableName, payload, primaryKey);
+            rowData = { ...formatted, [primaryKey]: rowId };
+        }
+        else {
+            const formatted = {};
+            if (payload && typeof payload === 'object') {
+                for (const k of Object.keys(payload)) {
+                    formatted[k] = (0, schema_manager_js_1.formatValueForStorage)(payload[k]);
+                }
+            }
+            rowData = { ...formatted, [primaryKey]: rowId };
+        }
+        const keys = Object.keys(rowData);
+        if (keys.length === 0)
+            return;
+        const existing = await tx.execute(`SELECT 1 FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [rowId]);
+        if (existing && existing.length > 0) {
+            // Row exists -> perform UPDATE
+            const updateKeys = keys.filter((k) => k !== primaryKey);
+            if (updateKeys.length > 0) {
+                const setClause = updateKeys.map((k) => `${(0, sql_js_1.escapeIdentifier)(k)} = ?`).join(', ');
+                const values = updateKeys.map((k) => rowData[k]);
+                values.push(rowId);
+                await tx.execute(`UPDATE ${safeTable} SET ${setClause} WHERE ${safePk} = ?`, values);
+            }
+        }
+        else {
+            // Row does not exist -> perform INSERT
+            const cols = keys.map((k) => (0, sql_js_1.escapeIdentifier)(k)).join(', ');
+            const placeholders = keys.map(() => '?').join(', ');
+            const values = keys.map((k) => rowData[k]);
+            await tx.execute(`INSERT INTO ${safeTable} (${cols}) VALUES (${placeholders})`, values);
+        }
+    }
+    /**
+     * Fetches an existing row from a local table by primary key.
+     */
+    static async fetchRow(tx, tableName, rowId, primaryKey = 'id', options) {
+        const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
+        const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
+        const sm = options?.schemaManager ?? defaultSchemaManager;
+        if (options?.autoSchema) {
+            await sm.ensureTable(tx, tableName, primaryKey);
+        }
+        const rows = await tx.execute(`SELECT * FROM ${safeTable} WHERE ${safePk} = ? LIMIT 1`, [rowId]);
+        return rows && rows.length > 0 ? rows[0] : null;
+    }
+}
+exports.TableManager = TableManager;

package/dist/core/types.d.ts

@@ -0,0 +1,73 @@
+export type SyncOp = 'INSERT' | 'UPDATE' | 'DELETE';
+export type OutboxStatus = 'PENDING' | 'PROCESSING' | 'FAILED';
+export interface SyncOperation {
+    id: string;
+    tableName: string;
+    rowId: string;
+    operation: SyncOp;
+    payload: Record<string, any> | null;
+    timestamp: number;
+}
+export interface OutboxRecord extends SyncOperation {
+    status: OutboxStatus;
+    retryCount: number;
+    lastError?: string | null;
+}
+export interface DeltaChange {
+    tableName: string;
+    operation: SyncOp;
+    rowId: string;
+    payload: Record<string, any> | null;
+    timestamp?: number;
+}
+export interface DeltaChanges {
+    timestamp: number;
+    changes: DeltaChange[];
+}
+export type ConflictResolution = 'apply-remote' | 'keep-local' | {
+    mergePayload: Record<string, any>;
+};
+export interface ConflictContext {
+    tableName: string;
+    rowId: string;
+    remoteChange: DeltaChange;
+    localOutboxRecord?: OutboxRecord;
+    localRow?: Record<string, any> | null;
+}
+export type ConflictResolver = (context: ConflictContext) => ConflictResolution | Promise<ConflictResolution>;
+export type ConflictStrategy = 'last-write-wins' | 'server-wins' | 'client-wins';
+export interface NetworkStatusProvider {
+    isOnline(): boolean | Promise<boolean>;
+    subscribe(callback: (isOnline: boolean) => void): () => void;
+}
+export interface RetryConfig {
+    /** Maximum retry attempts before marking outbox record as permanently FAILED. Set to `Infinity` or `-1` for infinite retries. Default: 5 */
+    maxRetries?: number;
+    /** Initial delay before retrying failed operations in milliseconds. Default: 1000 */
+    initialDelayMs?: number;
+    /** Backoff multiplier applied on consecutive failures (e.g. 2 for exponential). Default: 1.5 */
+    backoffMultiplier?: number;
+    /** Maximum capped delay between retries in milliseconds. Default: 30000 */
+    maxDelayMs?: number;
+    /** Custom predicate deciding whether an error is retryable. Return false for non-retryable errors like permanent RLS violations. */
+    shouldRetry?: (error: any, operation: SyncOperation) => boolean;
+}
+export interface MutateOptions {
+    primaryKey?: string;
+    tx?: any;
+    customTimestamp?: number;
+    skipOutbox?: boolean;
+}
+export interface TableChangeEvent {
+    operation: SyncOp;
+    rowId: string;
+    payload?: Record<string, any> | null;
+    source: 'local' | 'remote';
+}
+export interface QueryOptions {
+    where?: Record<string, any>;
+    orderBy?: string;
+    order?: 'asc' | 'desc' | 'ASC' | 'DESC';
+    limit?: number;
+    offset?: number;
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export * from './core/client.js';
+export * from './core/types.js';
+export * from './core/sync-worker.js';
+export * from './core/conflict.js';
+export * from './core/outbox-store.js';
+export * from './core/meta-store.js';
+export * from './core/table-manager.js';
+export * from './core/schema-manager.js';
+export * from './reactive/event-emitter.js';
+export * from './adapters/local/index.js';
+export * from './adapters/remote/index.js';
+export * from './adapters/network/index.js';
+export * from './config/index.js';
+export * from './react/index.js';
+export * from './utils/uuid.js';
+export * from './utils/sql.js';
+export * from './utils/logger.js';

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+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 });
+__exportStar(require("./core/client.js"), exports);
+__exportStar(require("./core/types.js"), exports);
+__exportStar(require("./core/sync-worker.js"), exports);
+__exportStar(require("./core/conflict.js"), exports);
+__exportStar(require("./core/outbox-store.js"), exports);
+__exportStar(require("./core/meta-store.js"), exports);
+__exportStar(require("./core/table-manager.js"), exports);
+__exportStar(require("./core/schema-manager.js"), exports);
+__exportStar(require("./reactive/event-emitter.js"), exports);
+__exportStar(require("./adapters/local/index.js"), exports);
+__exportStar(require("./adapters/remote/index.js"), exports);
+__exportStar(require("./adapters/network/index.js"), exports);
+__exportStar(require("./config/index.js"), exports);
+__exportStar(require("./react/index.js"), exports);
+__exportStar(require("./utils/uuid.js"), exports);
+__exportStar(require("./utils/sql.js"), exports);
+__exportStar(require("./utils/logger.js"), exports);

package/dist/react/index.d.ts

@@ -0,0 +1,34 @@
+import { LocalFirstClient } from '../core/client.js';
+import { QueryOptions } from '../core/types.js';
+export type LiveQueryFn<T> = (client: LocalFirstClient) => Promise<T[]> | T[];
+/**
+ * Hook to execute a live reactive table query that automatically re-runs
+ * whenever the table is mutated locally or via incoming remote delta.
+ *
+ * Supports 3 flexible usage patterns:
+ * 1. Zero-SQL (all rows):
+ *    const { data: todos } = useLiveQuery<Todo>(client, 'todos');
+ *
+ * 2. Declarative options (filtering & sorting without SQL):
+ *    const { data: active } = useLiveQuery<Todo>(client, 'todos', {
+ *      where: { completed: 0 },
+ *      orderBy: 'created_at',
+ *      order: 'desc'
+ *    });
+ *
+ * 3. Custom query callback (advanced raw SQL / joins):
+ *    const { data } = useLiveQuery(client, 'todos', (c) => c.db.execute('SELECT ...'));
+ */
+export declare function useLiveQuery<T = any>(client: LocalFirstClient | null | undefined, tableName: string, queryOrOptions?: LiveQueryFn<T> | QueryOptions): {
+    data: T[];
+    refetch: () => Promise<void>;
+    loading: boolean;
+};
+/**
+ * Hook that tracks the status and pending items in sync_outbox in real time.
+ */
+export declare function useOutboxStatus(client: LocalFirstClient | null | undefined): {
+    pendingCount: number;
+    pendingRecords: any[];
+    refresh: () => Promise<void>;
+};