@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/client/index.d.ts

@@ -1,344 +1,217 @@
-/** Query parameter types: named (object) or positional (array). */
-type Params = Record<string, unknown> | unknown[];
-type WriteConcernLevel = 'local' | 'majority' | 'all';
-interface WriteConcern {
-    level: WriteConcernLevel;
-    timeoutMs?: number;
-}
-type ReadConcernLevel = 'local' | 'majority' | 'linearizable';
-interface ReadConcern {
-    level: ReadConcernLevel;
+export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-DPAm2AKG.js';
+import { C as ConflictResolver, R as ReplicationBatch } from '../types-C_D8IhpO.js';
+export { a as ConflictContext, b as ConflictResolution } from '../types-C_D8IhpO.js';
+import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-1JHu8pid.js';
+import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-CLWmH5Ln.js';
+export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-CLWmH5Ln.js';
+import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-CL6piSnD.js';
+import { e as DeviceSyncPort, D as Database } from '../database-BY0L5Q2n.js';
+import { h as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../types-zhnRXrsb.js';
+import { Q as QueryResponse, E as ExecuteResponse, a as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-6KrSq2Hy.js';
+import '../operation-registry-9DcvxcE5.js';
+
+declare class SirannonClient extends DatabaseClient {
+    private readonly baseUrl;
+    constructor(url: string, options?: ClientOptions);
+    protected createTransport(databaseId: string): Transport;
+    protected resolveServerUrl(): string;
 }
-interface QueryOptions {
-    writeConcern?: WriteConcern;
-    readConcern?: ReadConcern;
+
+declare class RemoteLiveQuery<T> implements LiveQuery<T> {
+    private state;
+    private rows;
+    private readonly listeners;
+    private subscription;
+    private closed;
+    static open<T>(subscribe: (handlers: LiveHandlers) => Promise<RemoteSubscription>): Promise<RemoteLiveQuery<T>>;
+    getState(): LiveQueryState<T>;
+    subscribe(listener: (update: LiveUpdate<T>) => void): () => void;
+    close(): Promise<void>;
+    private handlers;
+    private replace;
+    private apply;
+    private markRevalidating;
+    private fail;
+    private publish;
 }
-/** CDC operation type. */
-type ChangeOperation = 'insert' | 'update' | 'delete';
-/** Event emitted when a watched table row changes. */
-interface ChangeEvent<T = Record<string, unknown>> {
-    type: ChangeOperation;
+
+interface SnapshotProgress {
     table: string;
-    row: T;
-    oldRow?: T;
-    seq: bigint;
-    timestamp: number;
+    tableLoadedRows: number;
+    tableTotalRows: number;
+    loadedRows: number;
+    totalRows: number;
 }
-/**
- * Durability level in force while a bulk load runs. SQLite sanctions 'off' for
- * a from-scratch load that the operator can re-run after a power loss; 'off'
- * gives up corruption safety, so it fits only a load that starts from nothing.
- * 'normal' keeps WAL-mode corruption safety and suits loads into a database
- * that already holds data the operator cannot afford to lose.
- */
-type BulkLoadDurability = 'off' | 'normal';
-/** Aggregate outcome of a bulk load. Summed rather than per-row so a
- * million-row load never holds a million result objects in memory. */
-interface BulkLoadResult {
-    rowsLoaded: number;
-    changes: number;
-}
-/** Options for the client SDK. */
-interface ClientOptions {
-    /** Transport to use. Default: 'websocket'. */
-    transport?: 'websocket' | 'http';
-    /** Custom headers for HTTP requests. */
+interface SnapshotDownloadOptions {
+    url: string;
+    databaseId: string;
     headers?: Record<string, string>;
-    /** WebSocket subprotocols sent during the browser-compatible handshake. */
-    webSocketProtocols?: string | string[];
-    /** Reconnect on WebSocket disconnect. Default: true. */
-    autoReconnect?: boolean;
-    /** Reconnect interval in ms. Default: 1000. */
-    reconnectInterval?: number;
-    /**
-     * Per-request timeout in milliseconds for the WebSocket transport. A bulk
-     * load or batch of tens of millions of rows can legitimately run longer than
-     * the default, so raise this for large writes. Set to 0 to wait indefinitely.
-     * Default: 30000.
-     */
-    requestTimeout?: number;
-}
-
-interface QueryResponse {
-    rows: Record<string, unknown>[];
-}
-interface ExecuteResponse {
-    changes: number;
-    lastInsertRowId: number | string;
+    pageSize?: number;
+    requestTimeoutMs?: number;
+    onProgress?: (progress: SnapshotProgress) => void;
 }
-interface TransactionResponse {
-    results: ExecuteResponse[];
+interface SnapshotDownloadResult {
+    startSeq: bigint;
+    epoch: string;
+    tables: string[];
+    loadedRows: number;
 }
-interface BatchResponse {
-    results: ExecuteResponse[];
-}
-type LoadResponse = BulkLoadResult;
+declare function downloadDatabaseSnapshot(port: DeviceSyncPort, options: SnapshotDownloadOptions): Promise<SnapshotDownloadResult>;
 
-/** Optional behaviours for a CDC subscription. */
-interface SubscribeOptions {
-    /**
-     * Invoked when a reconnect cannot replay missed changes because they fell
-     * outside the server's retained history. The subscription continues live
-     * from the current moment; treat any prior state as stale and re-read.
-     */
-    onReset?: () => void;
-}
 /**
- * Transport layer for communicating with a sirannon-db server.
- * Each transport instance is bound to a specific database.
+ * Builds a remote CDC subscription with optional row-level filters.
+ * Mirrors the core {@link SubscriptionBuilder} interface but returns
+ * a promise from `subscribe()` since confirming the subscription
+ * requires a server round-trip.
  */
-interface Transport {
-    query(sql: string, params?: Params, readConcern?: ReadConcern): Promise<QueryResponse>;
-    execute(sql: string, params?: Params): Promise<ExecuteResponse>;
-    transaction(statements: Array<{
-        sql: string;
-        params?: Params;
-    }>): Promise<TransactionResponse>;
-    batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
-    load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
-    subscribe(table: string, filter: Record<string, unknown> | undefined, callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
-    close(): void;
-}
-/** Handle for an active remote subscription. */
-interface RemoteSubscription {
-    unsubscribe(): void;
-}
-/** Builder for creating remote CDC subscriptions with optional filters. */
-interface RemoteSubscriptionBuilder {
+declare class RemoteSubscriptionBuilderImpl implements RemoteSubscriptionBuilder {
+    private readonly table;
+    private readonly transport;
+    private conditions;
+    constructor(table: string, transport: Transport);
     filter(conditions: Record<string, unknown>): RemoteSubscriptionBuilder;
     subscribe(callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
 }
-/**
- * Error originating from a remote sirannon-db server.
- * Carries the machine-readable error code from the server's error response.
- */
-declare class RemoteError extends Error {
-    readonly code: string;
-    constructor(code: string, message: string);
-}
 
-/** Options for {@link RemoteDatabase.loadAll}. */
-interface LoadAllOptions {
-    /**
-     * Rows per batch sent to the server. Each batch is one request, so it must
-     * fit under the server's `maxBodyBytes`; widen that cap or lower this for
-     * wide rows. Default: 1000.
-     */
+interface SyncControllerOptions {
+    url: string;
+    databaseId: string;
+    tables: readonly string[];
+    headers?: Record<string, string>;
     batchSize?: number;
-    /** Durability during the load. Default: 'off'. */
-    durability?: BulkLoadDurability;
+    pushIntervalMs?: number;
+    ackIntervalMs?: number;
+    maxPushRetryDelayMs?: number;
+    requestTimeout?: number;
+    autoResync?: boolean;
+    snapshotRetryDelayMs?: number;
+    maxSnapshotRetryDelayMs?: number;
+    snapshotPageSize?: number;
+    immediateAckAfterChanges?: number;
+    resolver?: ConflictResolver | ((table: string) => ConflictResolver);
+    onChange?: (event: ChangeEvent) => void;
+    onResyncRequired?: () => void;
+    onSnapshotProgress?: (progress: SnapshotProgress) => void;
+    onSnapshotComplete?: (outcome: SnapshotOutcome) => void;
 }
-/**
- * Proxy for a remote sirannon-db database. Mirrors the core
- * {@link Database} query interface with async methods that send
- * requests to the server via the configured transport.
- */
-declare class RemoteDatabase {
-    readonly id: string;
-    private readonly transport;
-    private readonly onDispose?;
-    constructor(id: string, transport: Transport, onDispose?: (() => void) | undefined);
-    /**
-     * Execute a SELECT and return all matching rows.
-     *
-     * ```ts
-     * const users = await db.query<{ id: number; name: string }>(
-     *   'SELECT * FROM users WHERE age > ?',
-     *   [21],
-     * )
-     * ```
-     */
-    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
-    /**
-     * Execute a mutation (INSERT, UPDATE, DELETE) and return
-     * the number of affected rows and last insert row ID.
-     */
-    execute(sql: string, params?: Params): Promise<ExecuteResponse>;
-    /**
-     * Execute multiple statements as a single atomic transaction.
-     * Returns an array of results, one per statement.
-     *
-     * The whole list travels in one request and commits or rolls back as a
-     * unit, so the client is never in the loop between statements.
-     */
-    transaction(statements: Array<{
-        sql: string;
-        params?: Params;
-    }>): Promise<ExecuteResponse[]>;
-    /**
-     * Run the same statement once per parameter set as a single atomic
-     * transaction that commits with one fsync. Returns one result per
-     * parameter set, in order. Use this for a burst of same-shape writes
-     * (an import, a bulk insert) that must all commit or all roll back.
-     */
-    batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<ExecuteResponse[]>;
-    /**
-     * Load a whole dataset through the same statement, batching it into requests
-     * for you and paying the one fsyncing WAL checkpoint once, after the final
-     * batch. The configured durability is restored after every batch, so an
-     * import that stops partway never leaves the writer at the relaxed level.
-     * Prefer this over {@link load} for anything larger than a single request:
-     * it runs the finalize itself, so there is no checkpoint flag to forget.
-     *
-     * Accepts a synchronous or asynchronous iterable of parameter sets, so rows
-     * can stream from a file or the network without being held in memory at
-     * once. Returns the total rows loaded and changes applied.
-     *
-     * ```ts
-     * const summary = await db.loadAll(
-     *   'INSERT INTO events (id, payload) VALUES (?, ?)',
-     *   rowStream,
-     *   { batchSize: 5000, durability: 'off' },
-     * )
-     * ```
-     */
-    loadAll(sql: string, rows: Iterable<Params> | AsyncIterable<Params>, options?: LoadAllOptions): Promise<BulkLoadResult>;
-    /**
-     * Load one batch of rows through the same statement with writer durability
-     * relaxed for the duration, then restored before this resolves. This is the
-     * low-level primitive; prefer {@link loadAll} for a dataset that spans more
-     * than one request, since it runs the finalize itself rather than relying on
-     * a `checkpoint` flag.
-     *
-     * Returns the total rows loaded and changes applied. When splitting a dataset
-     * across many `load` calls by hand, pass `checkpoint: false` on every call
-     * but the last so the one fsyncing WAL checkpoint runs once at the end; the
-     * configured durability is restored after each call regardless.
-     */
-    load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<BulkLoadResult>;
+type SnapshotOutcome = {
+    ok: true;
+    error: null;
+    databaseUsable: true;
+    retrying: false;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+    databaseUsable: boolean;
+    retrying: boolean;
+};
+type SyncState = 'stopped' | 'starting' | 'running' | 'paused' | 'snapshotting';
+interface SnapshotOptions {
+    pageSize?: number;
+    onProgress?: (progress: SnapshotProgress) => void;
+}
+interface SyncStatus {
+    state: SyncState;
+    deviceId: string | null;
+    serverCapabilities: string[] | null;
+    schemaVersion: number | null;
+    pendingPushCount: number;
+    lastPushedSeq: bigint;
+    lastPulledSeq: bigint | null;
+    pushCaughtUp: boolean;
+    resyncRequired: boolean;
+    lastError: {
+        code: string;
+        message: string;
+    } | null;
+}
+
+declare class SyncController {
+    private readonly db;
+    private readonly options;
+    private readonly baseUrl;
+    private readonly pushIntervalMs;
+    private readonly maxPushRetryDelayMs;
+    private readonly pull;
+    private readonly push;
+    private readonly resync;
+    private port;
+    private deviceId;
+    private capabilities;
+    private schemaVersion;
+    private state;
+    private pullRetryTimer;
+    private consecutivePullFailures;
+    private lastError;
+    constructor(db: Database, options: SyncControllerOptions);
+    start(): Promise<void>;
+    pause(): void;
+    resume(): Promise<void>;
+    stop(): Promise<void>;
+    status(): Promise<SyncStatus>;
+    triggerPush(): void;
+    private verifyCapabilities;
+    private localSchemaVersion;
+    private reconcileSchema;
+    private markResyncRequired;
+    downloadSnapshot(options?: SnapshotOptions): Promise<void>;
     /**
-     * Start building a CDC subscription for the given table.
-     * Chain `.filter()` to narrow the events, then call `.subscribe()`
-     * with a callback to begin receiving real-time change events.
-     *
-     * ```ts
-     * const sub = await db
-     *   .on('orders')
-     *   .filter({ status: 'pending' })
-     *   .subscribe(event => console.log(event))
-     *
-     * // Later:
-     * sub.unsubscribe()
-     * ```
+     * Answers whether the local database serves reads and writes again. A failure
+     * before the wipe begins leaves it intact, while one after it leaves every
+     * statement refused with `SNAPSHOT_IN_PROGRESS` until a later copy succeeds,
+     * so the application learns which of the two it is rather than assuming.
      */
-    on(table: string): RemoteSubscriptionBuilder;
+    private snapshotGateOpen;
+    private recordError;
+    private handleApplyFailure;
+    private reopenPull;
     /**
-     * Close the transport for this database. After calling `close()`,
-     * all pending requests are rejected and new calls will throw.
+     * Opens the pull subscription, reconciling migrations when the server refuses
+     * it because this device is behind. A device that only reads never pushes, so
+     * the subscribe refusal is the sole point at which it can learn that the
+     * server has migrated; without this it would retry the same refused
+     * subscription forever and silently receive nothing.
      */
-    close(): void;
+    private openPull;
+    private teardownStream;
 }
 
-interface TopologyAwareClientOptions extends ClientOptions {
-    endpoints?: string[];
-    primary?: string;
-    replicas?: string[];
-    readPreference?: 'primary' | 'replica' | 'nearest';
-    discovery?: 'static' | 'coordinator';
-    readConcern?: ReadConcernLevel;
-}
-declare class SirannonClient {
-    private readonly baseUrl;
-    private readonly wsBaseUrl;
-    private readonly transport;
-    private readonly headers;
-    private readonly webSocketProtocols;
-    private readonly autoReconnect;
-    private readonly reconnectInterval;
-    private readonly requestTimeout;
-    private readonly databases;
-    private closed;
-    private readonly topologyEnabled;
-    private readonly primaryUrl;
-    private readonly replicaUrls;
-    private readonly readPreference;
-    private readonly discovery;
-    private readonly readConcern;
-    private readonly starterEndpoints;
-    private readonly clusterRouting;
-    private readonly topologyTransports;
-    private latencies;
-    private latencyMeasuredAt;
-    private latencyMeasuring;
-    private readonly LATENCY_TTL_MS;
-    private removedReplicas;
-    constructor(url: string, options?: ClientOptions);
-    constructor(options: TopologyAwareClientOptions);
-    database(id: string): RemoteDatabase;
-    close(): void;
-    private createTransport;
-    private createTransportForUrl;
-    _createTransportForEndpoint(url: string, databaseId: string): Transport;
-    _getReadEndpoint(databaseId?: string, readConcern?: ReadConcernLevel): Promise<string>;
-    _getWriteEndpoint(databaseId?: string): Promise<string>;
-    _getReadConcern(): ReadConcernLevel | undefined;
-    _usesCoordinatorDiscovery(): boolean;
-    _removeReplica(url: string): void;
-    private ensureLatencyMeasured;
-    private measureLatencies;
-    _refreshClusterRouting(databaseId: string): Promise<void>;
-    private ensureClusterRouting;
-    private clusterDiscoveryCandidates;
-    _unregisterTopologyTransport(databaseId: string, transport: TopologyAwareTransport): void;
-    private notifyClusterRoutingChanged;
+interface ChangesRequest {
+    schemaVersion?: number;
+    batch: {
+        sourceNodeId: string;
+        batchId: string;
+        fromSeq: string;
+        toSeq: string;
+        hlcRange: {
+            min: string;
+            max: string;
+        };
+        changes: {
+            table: string;
+            operation: string;
+            rowId: string;
+            primaryKey: Record<string, unknown>;
+            hlc: string;
+            txId: string;
+            nodeId: string;
+            newData: Record<string, unknown> | null;
+            oldData: Record<string, unknown> | null;
+        }[];
+        checksum: string;
+    };
 }
-
-declare class TopologyAwareTransport implements Transport {
-    private readonly databaseId;
-    private readonly client;
-    private closed;
-    private readTransport;
-    private writeTransport;
-    private subscriptionTransport;
-    private readTransportRequest;
-    private writeTransportRequest;
-    private subscriptionTransportRequest;
-    private subscriptionOperation;
-    private activeSubscriptions;
-    private nextSubscriptionId;
-    private currentReadUrl;
-    private currentWriteUrl;
-    private currentSubscriptionUrl;
-    constructor(databaseId: string, client: SirannonClient);
-    query(sql: string, params?: Params): Promise<QueryResponse>;
-    execute(sql: string, params?: Params): Promise<ExecuteResponse>;
-    transaction(statements: Array<{
-        sql: string;
-        params?: Params;
-    }>): Promise<TransactionResponse>;
-    batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
-    load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
-    subscribe(table: string, filter: Record<string, unknown> | undefined, callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
-    _handleClusterRoutingChanged(): Promise<void>;
-    close(): void;
-    private subscribeOnCurrentEndpoint;
-    private createSubscriptionHandle;
-    private migrateSubscriptionsToCurrentEndpoint;
-    private getReadTransport;
-    private resolveReadTransport;
-    private getWriteTransport;
-    private resolveWriteTransport;
-    private getSubscriptionTransport;
-    private resolveSubscriptionTransport;
-    private closeSubscriptionTransport;
-    private withSubscriptionOperation;
-    private assertOpen;
+interface ChangesResponse {
+    applied: number;
+    skipped: number;
+    conflicts: number;
 }
 
-/**
- * Builds a remote CDC subscription with optional row-level filters.
- * Mirrors the core {@link SubscriptionBuilder} interface but returns
- * a promise from `subscribe()` since confirming the subscription
- * requires a server round-trip.
- */
-declare class RemoteSubscriptionBuilderImpl implements RemoteSubscriptionBuilder {
-    private readonly table;
-    private readonly transport;
-    private conditions;
-    constructor(table: string, transport: Transport);
-    filter(conditions: Record<string, unknown>): RemoteSubscriptionBuilder;
-    subscribe(callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
-}
+declare function encodeSyncBatch(batch: ReplicationBatch): ChangesRequest['batch'];
+declare function pushSyncBatch(baseUrl: string, databaseId: string, batch: ReplicationBatch, headers?: Record<string, string>, timeoutMs?: number, schemaVersion?: number): Promise<ChangesResponse>;
 
 /**
  * HTTP transport for sirannon-db. Sends requests via `fetch` to the
@@ -347,6 +220,7 @@ declare class RemoteSubscriptionBuilderImpl implements RemoteSubscriptionBuilder
  * HTTP; use {@link WebSocketTransport} for CDC subscriptions.
  */
 declare class HttpTransport implements Transport {
+    readonly carriesReadConcern = true;
     private readonly baseUrl;
     private readonly headers;
     private closed;
@@ -359,20 +233,37 @@ declare class HttpTransport implements Transport {
     }>): Promise<TransactionResponse>;
     batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
     load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
+    queryNamed(name: string, args?: Record<string, unknown>, readConcern?: ReadConcern): Promise<QueryResponse>;
+    executeNamed(name: string, args?: Record<string, unknown>, writeConcern?: WriteConcern): Promise<TransactionResponse>;
+    liveSubscribe(): Promise<RemoteSubscription>;
     subscribe(_table: string, _filter: Record<string, unknown> | undefined, _callback: (event: ChangeEvent) => void): Promise<RemoteSubscription>;
     close(): void;
     private post;
 }
 
+/**
+ * WebSocket transport for sirannon-db. Connects to
+ * `ws(s)://host:port/db/{id}` and supports query, execute, transaction,
+ * batch, load, and real-time CDC subscriptions over a single persistent
+ * connection.
+ *
+ * Connections are established lazily on first use and will
+ * auto-reconnect (with subscription restoration) when
+ * `autoReconnect` is enabled.
+ */
 declare class WebSocketTransport implements Transport {
+    readonly carriesReadConcern = true;
     private ws;
     private readonly url;
     private readonly autoReconnect;
     private readonly reconnectInterval;
     private readonly requestTimeout;
     private readonly protocols;
-    private pendingRequests;
+    private readonly headers;
+    private refusal;
+    private readonly pending;
     private activeSubscriptions;
+    private readonly liveQueries;
     private idCounter;
     private closed;
     private connectPromise;
@@ -382,8 +273,9 @@ declare class WebSocketTransport implements Transport {
         reconnectInterval?: number;
         requestTimeout?: number;
         protocols?: string | string[];
+        headers?: Record<string, string>;
     });
-    query(sql: string, params?: Params): Promise<QueryResponse>;
+    query(sql: string, params?: Params, readConcern?: ReadConcern): Promise<QueryResponse>;
     execute(sql: string, params?: Params): Promise<ExecuteResponse>;
     transaction(statements: Array<{
         sql: string;
@@ -391,18 +283,21 @@ declare class WebSocketTransport implements Transport {
     }>): Promise<TransactionResponse>;
     batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
     load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
+    queryNamed(name: string, args?: Record<string, unknown>, readConcern?: ReadConcern): Promise<QueryResponse>;
+    executeNamed(name: string, args?: Record<string, unknown>, writeConcern?: WriteConcern): Promise<TransactionResponse>;
+    liveSubscribe(name: string, args: Record<string, unknown> | undefined, handlers: LiveHandlers, registryDigest?: RegistryDigestSource): Promise<RemoteSubscription>;
     subscribe(table: string, filter: Record<string, unknown> | undefined, callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
+    private sendUnsubscribe;
+    ack(deviceId: string, seq: bigint): Promise<AckResponse>;
     close(): void;
     private nextId;
     private ensureConnected;
     private connect;
-    private handleMessage;
     private handleDisconnect;
     private scheduleReconnect;
     private resubscribeAll;
     private request;
-    private rejectAllPending;
     private cancelReconnect;
 }
 
-export { HttpTransport, type LoadAllOptions, RemoteDatabase, RemoteError, type RemoteSubscription, type RemoteSubscriptionBuilder, RemoteSubscriptionBuilderImpl, SirannonClient, type TopologyAwareClientOptions, type Transport, WebSocketTransport };
+export { ConflictResolver, HttpTransport, LiveHandlers, RegistryDigestSource, RemoteLiveQuery, RemoteSubscription, RemoteSubscriptionBuilder, RemoteSubscriptionBuilderImpl, SirannonClient, type SnapshotDownloadOptions, type SnapshotDownloadResult, type SnapshotOptions, type SnapshotOutcome, type SnapshotProgress, SyncController, type SyncControllerOptions, type SyncState, type SyncStatus, Transport, WebSocketTransport, downloadDatabaseSnapshot, encodeSyncBatch, pushSyncBatch };