@topgunbuild/client 0.3.0 → 0.5.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { LWWRecord, ORMapRecord, PredicateNode, LWWMap, ORMap, Timestamp, HLC, NodeHealth, ConnectionPoolConfig, PartitionRouterConfig, PartitionMap, ClusterClientConfig } from '@topgunbuild/core';
+import { LWWRecord, ORMapRecord, PredicateNode, ConflictResolverDef, MergeRejection, Timestamp, LWWMap, ORMap, HLC, EntryProcessorDef, EntryProcessorResult, PNCounter, PNCounterState, JournalEvent, JournalEventType, NodeHealth, ConnectionPoolConfig, PartitionRouterConfig, PartitionMap, ClusterClientConfig } from '@topgunbuild/core';
 export { LWWMap, LWWRecord, PredicateNode, Predicates } from '@topgunbuild/core';
 import pino from 'pino';
 
@@ -35,6 +35,65 @@ interface IStorageAdapter {
     getAllKeys(): Promise<string[]>;
 }
 
+/**
+ * Represents a change event for tracking data mutations.
+ */
+interface ChangeEvent<T> {
+    /** Type of change: 'add' for new entries, 'update' for modified entries, 'remove' for deleted entries */
+    type: 'add' | 'update' | 'remove';
+    /** The key of the changed entry */
+    key: string;
+    /** New value (present for 'add' and 'update') */
+    value?: T;
+    /** Previous value (present for 'update' and 'remove') */
+    previousValue?: T;
+    /** HLC timestamp of the change */
+    timestamp: number;
+}
+/**
+ * ChangeTracker computes differences between snapshots of a Map.
+ * Used to track add/update/remove changes for subscription notifications.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new ChangeTracker<Todo>();
+ *
+ * // First snapshot
+ * const changes1 = tracker.computeChanges(
+ *   new Map([['a', { title: 'Todo A' }]]),
+ *   Date.now()
+ * );
+ * // changes1 = [{ type: 'add', key: 'a', value: { title: 'Todo A' }, timestamp: ... }]
+ *
+ * // Second snapshot with update
+ * const changes2 = tracker.computeChanges(
+ *   new Map([['a', { title: 'Todo A Updated' }]]),
+ *   Date.now()
+ * );
+ * // changes2 = [{ type: 'update', key: 'a', value: { title: 'Todo A Updated' }, previousValue: { title: 'Todo A' }, timestamp: ... }]
+ * ```
+ */
+declare class ChangeTracker<T> {
+    private previousSnapshot;
+    /**
+     * Computes changes between previous and current state.
+     * Updates internal snapshot after computation.
+     *
+     * @param current - Current state as a Map
+     * @param timestamp - HLC timestamp for the changes
+     * @returns Array of change events (may be empty if no changes)
+     */
+    computeChanges(current: Map<string, T>, timestamp: number): ChangeEvent<T>[];
+    /**
+     * Reset tracker (e.g., on query change or reconnect)
+     */
+    reset(): void;
+    /**
+     * Get current snapshot size for debugging/metrics
+     */
+    get size(): number;
+}
+
 interface QueryFilter {
     where?: Record<string, any>;
     predicate?: PredicateNode;
@@ -55,6 +114,9 @@ declare class QueryHandle<T> {
     private filter;
     private listeners;
     private currentResults;
+    private changeTracker;
+    private pendingChanges;
+    private changeListeners;
     constructor(syncEngine: SyncEngine, mapName: string, filter?: QueryFilter);
     subscribe(callback: (results: QueryResultItem<T>[]) => void): () => void;
     private loadInitialLocalData;
@@ -79,6 +141,47 @@ declare class QueryHandle<T> {
      * Called by SyncEngine when server sends a live update
      */
     onUpdate(key: string, value: T | null): void;
+    /**
+     * Subscribe to change events (Phase 5.1).
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = handle.onChanges((changes) => {
+     *   for (const change of changes) {
+     *     if (change.type === 'add') {
+     *       console.log('Added:', change.key, change.value);
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    onChanges(listener: (changes: ChangeEvent<T>[]) => void): () => void;
+    /**
+     * Get and clear pending changes (Phase 5.1).
+     * Call this to retrieve all changes since the last consume.
+     */
+    consumeChanges(): ChangeEvent<T>[];
+    /**
+     * Get last change without consuming (Phase 5.1).
+     * Returns null if no pending changes.
+     */
+    getLastChange(): ChangeEvent<T> | null;
+    /**
+     * Get all pending changes without consuming (Phase 5.1).
+     */
+    getPendingChanges(): ChangeEvent<T>[];
+    /**
+     * Clear all pending changes (Phase 5.1).
+     */
+    clearChanges(): void;
+    /**
+     * Reset change tracker (Phase 5.1).
+     * Use when query filter changes or on reconnect.
+     */
+    resetChangeTracker(): void;
+    private computeAndNotifyChanges;
+    private notifyChangeListeners;
     private notify;
     private getSortedResults;
     getFilter(): QueryFilter;
@@ -402,6 +505,140 @@ interface SingleServerProviderConfig {
     maxReconnectDelayMs?: number;
 }
 
+/**
+ * Registered resolver info returned from server.
+ */
+interface ResolverInfo {
+    mapName: string;
+    name: string;
+    priority?: number;
+    keyPattern?: string;
+}
+/**
+ * Registration result from server.
+ */
+interface RegisterResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Client-side manager for conflict resolvers.
+ *
+ * Provides API for:
+ * - Registering conflict resolvers on server
+ * - Unregistering resolvers
+ * - Listing registered resolvers
+ * - Subscribing to merge rejection events
+ */
+declare class ConflictResolverClient {
+    private readonly syncEngine;
+    private readonly rejectionListeners;
+    private readonly pendingRequests;
+    private static readonly REQUEST_TIMEOUT;
+    constructor(syncEngine: SyncEngine);
+    /**
+     * Register a conflict resolver on the server.
+     *
+     * @param mapName The map to register the resolver for
+     * @param resolver The resolver definition
+     * @returns Promise resolving to registration result
+     *
+     * @example
+     * ```typescript
+     * // Register a first-write-wins resolver for bookings
+     * await client.resolvers.register('bookings', {
+     *   name: 'first-write-wins',
+     *   code: `
+     *     if (context.localValue !== undefined) {
+     *       return { action: 'reject', reason: 'Slot already booked' };
+     *     }
+     *     return { action: 'accept', value: context.remoteValue };
+     *   `,
+     *   priority: 100,
+     * });
+     * ```
+     */
+    register<V>(mapName: string, resolver: Omit<ConflictResolverDef<V>, 'fn'>): Promise<RegisterResult>;
+    /**
+     * Unregister a conflict resolver from the server.
+     *
+     * @param mapName The map the resolver is registered for
+     * @param resolverName The name of the resolver to unregister
+     * @returns Promise resolving to unregistration result
+     */
+    unregister(mapName: string, resolverName: string): Promise<RegisterResult>;
+    /**
+     * List registered conflict resolvers on the server.
+     *
+     * @param mapName Optional - filter by map name
+     * @returns Promise resolving to list of resolver info
+     */
+    list(mapName?: string): Promise<ResolverInfo[]>;
+    /**
+     * Subscribe to merge rejection events.
+     *
+     * @param listener Callback for rejection events
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = client.resolvers.onRejection((rejection) => {
+     *   console.log(`Merge rejected for ${rejection.key}: ${rejection.reason}`);
+     *   // Optionally refresh the local value
+     * });
+     *
+     * // Later...
+     * unsubscribe();
+     * ```
+     */
+    onRejection(listener: (rejection: MergeRejection) => void): () => void;
+    /**
+     * Handle REGISTER_RESOLVER_RESPONSE from server.
+     * Called by SyncEngine.
+     */
+    handleRegisterResponse(message: {
+        requestId: string;
+        success: boolean;
+        error?: string;
+    }): void;
+    /**
+     * Handle UNREGISTER_RESOLVER_RESPONSE from server.
+     * Called by SyncEngine.
+     */
+    handleUnregisterResponse(message: {
+        requestId: string;
+        success: boolean;
+        error?: string;
+    }): void;
+    /**
+     * Handle LIST_RESOLVERS_RESPONSE from server.
+     * Called by SyncEngine.
+     */
+    handleListResponse(message: {
+        requestId: string;
+        resolvers: ResolverInfo[];
+    }): void;
+    /**
+     * Handle MERGE_REJECTED from server.
+     * Called by SyncEngine.
+     */
+    handleMergeRejected(message: {
+        mapName: string;
+        key: string;
+        attemptedValue: unknown;
+        reason: string;
+        timestamp: Timestamp;
+    }): void;
+    /**
+     * Clear all pending requests (e.g., on disconnect).
+     */
+    clearPending(): void;
+    /**
+     * Get the number of registered rejection listeners.
+     */
+    get rejectionListenerCount(): number;
+}
+
 interface HeartbeatConfig {
     intervalMs: number;
     timeoutMs: number;
@@ -461,6 +698,7 @@ declare class SyncEngine {
     private highWaterMarkEmitted;
     private backpressureListeners;
     private pendingWriteConcernPromises;
+    private readonly conflictResolverClient;
     constructor(config: SyncEngineConfig);
     /**
      * Get the current connection state
@@ -700,6 +938,99 @@ declare class SyncEngine {
      * Cancel all pending Write Concern promises (e.g., on disconnect).
      */
     private cancelAllWriteConcernPromises;
+    /** Counter update listeners by name */
+    private counterUpdateListeners;
+    /**
+     * Subscribe to counter updates from server.
+     * @param name Counter name
+     * @param listener Callback when counter state is updated
+     * @returns Unsubscribe function
+     */
+    onCounterUpdate(name: string, listener: (state: any) => void): () => void;
+    /**
+     * Request initial counter state from server.
+     * @param name Counter name
+     */
+    requestCounter(name: string): void;
+    /**
+     * Sync local counter state to server.
+     * @param name Counter name
+     * @param state Counter state to sync
+     */
+    syncCounter(name: string, state: any): void;
+    /**
+     * Handle incoming counter update from server.
+     * Called by handleServerMessage for COUNTER_UPDATE messages.
+     */
+    private handleCounterUpdate;
+    /** Pending entry processor requests by requestId */
+    private pendingProcessorRequests;
+    /** Pending batch entry processor requests by requestId */
+    private pendingBatchProcessorRequests;
+    /** Default timeout for entry processor requests (ms) */
+    private static readonly PROCESSOR_TIMEOUT;
+    /**
+     * Execute an entry processor on a single key atomically.
+     *
+     * @param mapName Name of the map
+     * @param key Key to process
+     * @param processor Processor definition
+     * @returns Promise resolving to the processor result
+     */
+    executeOnKey<V, R = V>(mapName: string, key: string, processor: EntryProcessorDef<V, R>): Promise<EntryProcessorResult<R>>;
+    /**
+     * Execute an entry processor on multiple keys.
+     *
+     * @param mapName Name of the map
+     * @param keys Keys to process
+     * @param processor Processor definition
+     * @returns Promise resolving to a map of key -> result
+     */
+    executeOnKeys<V, R = V>(mapName: string, keys: string[], processor: EntryProcessorDef<V, R>): Promise<Map<string, EntryProcessorResult<R>>>;
+    /**
+     * Handle entry processor response from server.
+     * Called by handleServerMessage for ENTRY_PROCESS_RESPONSE messages.
+     */
+    private handleEntryProcessResponse;
+    /**
+     * Handle entry processor batch response from server.
+     * Called by handleServerMessage for ENTRY_PROCESS_BATCH_RESPONSE messages.
+     */
+    private handleEntryProcessBatchResponse;
+    /** Message listeners for journal and other generic messages */
+    private messageListeners;
+    /**
+     * Subscribe to all incoming messages.
+     * Used by EventJournalReader to receive journal events.
+     *
+     * @param event Event type (currently only 'message')
+     * @param handler Message handler
+     */
+    on(event: 'message', handler: (message: any) => void): void;
+    /**
+     * Unsubscribe from incoming messages.
+     *
+     * @param event Event type (currently only 'message')
+     * @param handler Message handler to remove
+     */
+    off(event: 'message', handler: (message: any) => void): void;
+    /**
+     * Send a message to the server.
+     * Public method for EventJournalReader and other components.
+     *
+     * @param message Message object to send
+     */
+    send(message: any): void;
+    /**
+     * Emit message to all listeners.
+     * Called internally when a message is received.
+     */
+    private emitMessage;
+    /**
+     * Get the conflict resolver client for registering custom resolvers
+     * and subscribing to merge rejection events.
+     */
+    getConflictResolverClient(): ConflictResolverClient;
 }
 
 interface ILock {
@@ -718,6 +1049,166 @@ declare class DistributedLock implements ILock {
     isLocked(): boolean;
 }
 
+/**
+ * Client-side handle for a PN Counter.
+ *
+ * Wraps the core PNCounterImpl and integrates with SyncEngine for:
+ * - Automatic sync to server when counter changes
+ * - Receiving remote updates from other clients
+ * - Local persistence via IStorageAdapter (IndexedDB in browser)
+ *
+ * @example
+ * ```typescript
+ * const counter = client.getPNCounter('likes:post-123');
+ * counter.increment(); // Immediate local update + sync to server
+ *
+ * counter.subscribe((value) => {
+ *   console.log('Current likes:', value);
+ * });
+ * ```
+ */
+declare class PNCounterHandle implements PNCounter {
+    private readonly counter;
+    private readonly name;
+    private readonly syncEngine;
+    private readonly storageAdapter?;
+    private syncScheduled;
+    private persistScheduled;
+    private unsubscribeFromUpdates?;
+    constructor(name: string, nodeId: string, syncEngine: SyncEngine, storageAdapter?: IStorageAdapter);
+    /**
+     * Restore counter state from local storage.
+     * Called during construction to recover offline state.
+     */
+    private restoreFromStorage;
+    /**
+     * Persist counter state to local storage.
+     * Debounced to avoid excessive writes during rapid operations.
+     */
+    private schedulePersist;
+    /**
+     * Actually persist state to storage.
+     */
+    private persistToStorage;
+    /**
+     * Get current counter value.
+     */
+    get(): number;
+    /**
+     * Increment by 1 and return new value.
+     */
+    increment(): number;
+    /**
+     * Decrement by 1 and return new value.
+     */
+    decrement(): number;
+    /**
+     * Add delta (positive or negative) and return new value.
+     */
+    addAndGet(delta: number): number;
+    /**
+     * Get state for sync.
+     */
+    getState(): PNCounterState;
+    /**
+     * Merge remote state.
+     */
+    merge(remote: PNCounterState): void;
+    /**
+     * Subscribe to value changes.
+     */
+    subscribe(listener: (value: number) => void): () => void;
+    /**
+     * Get the counter name.
+     */
+    getName(): string;
+    /**
+     * Cleanup resources.
+     */
+    dispose(): void;
+    /**
+     * Schedule sync to server with debouncing.
+     * Batches rapid increments to avoid network spam.
+     */
+    private scheduleSync;
+}
+
+/**
+ * Serialized journal event from network (bigint as string).
+ */
+interface JournalEventData {
+    sequence: string;
+    type: JournalEventType;
+    mapName: string;
+    key: string;
+    value?: unknown;
+    previousValue?: unknown;
+    timestamp: {
+        millis: number;
+        counter: number;
+        nodeId: string;
+    };
+    nodeId: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for journal subscription.
+ */
+interface JournalSubscribeOptions {
+    /** Start from specific sequence */
+    fromSequence?: bigint;
+    /** Filter by map name */
+    mapName?: string;
+    /** Filter by event types */
+    types?: JournalEventType[];
+}
+/**
+ * Client-side Event Journal Reader.
+ * Communicates with server to read and subscribe to journal events.
+ */
+declare class EventJournalReader {
+    private readonly syncEngine;
+    private readonly listeners;
+    private subscriptionCounter;
+    constructor(syncEngine: SyncEngine);
+    /**
+     * Read events from sequence with optional limit.
+     *
+     * @param sequence Starting sequence (inclusive)
+     * @param limit Maximum events to return (default: 100)
+     * @returns Promise resolving to array of events
+     */
+    readFrom(sequence: bigint, limit?: number): Promise<JournalEvent[]>;
+    /**
+     * Read events for a specific map.
+     *
+     * @param mapName Map name to filter
+     * @param sequence Starting sequence (default: 0n)
+     * @param limit Maximum events to return (default: 100)
+     */
+    readMapEvents(mapName: string, sequence?: bigint, limit?: number): Promise<JournalEvent[]>;
+    /**
+     * Subscribe to new journal events.
+     *
+     * @param listener Callback for each event
+     * @param options Subscription options
+     * @returns Unsubscribe function
+     */
+    subscribe(listener: (event: JournalEvent) => void, options?: JournalSubscribeOptions): () => void;
+    /**
+     * Get the latest sequence number from server.
+     */
+    getLatestSequence(): Promise<bigint>;
+    /**
+     * Parse network event data to JournalEvent.
+     */
+    private parseEvent;
+    /**
+     * Generate unique request ID.
+     */
+    private generateRequestId;
+}
+
 /**
  * Cluster mode configuration for TopGunClient.
  * When provided, the client connects to multiple nodes with partition-aware routing.
@@ -763,6 +1254,7 @@ declare class TopGunClient {
     private readonly maps;
     private readonly storageAdapter;
     private readonly topicHandles;
+    private readonly counters;
     private readonly clusterClient?;
     private readonly isClusterMode;
     private readonly clusterConfig?;
@@ -784,6 +1276,27 @@ declare class TopGunClient {
      * @param name The name of the topic.
      */
     topic(name: string): TopicHandle;
+    /**
+     * Retrieves a PN Counter instance. If the counter doesn't exist locally, it's created.
+     * PN Counters support increment and decrement operations that work offline
+     * and sync to server when connected.
+     *
+     * @param name The name of the counter (e.g., 'likes:post-123')
+     * @returns A PNCounterHandle instance
+     *
+     * @example
+     * ```typescript
+     * const likes = client.getPNCounter('likes:post-123');
+     * likes.increment(); // +1
+     * likes.decrement(); // -1
+     * likes.addAndGet(10); // +10
+     *
+     * likes.subscribe((value) => {
+     *   console.log('Current likes:', value);
+     * });
+     * ```
+     */
+    getPNCounter(name: string): PNCounterHandle;
     /**
      * Retrieves an LWWMap instance. If the map doesn't exist locally, it's created.
      * @param name The name of the map.
@@ -905,6 +1418,144 @@ declare class TopGunClient {
      * ```
      */
     onBackpressure(event: 'backpressure:high' | 'backpressure:low' | 'backpressure:paused' | 'backpressure:resumed' | 'operation:dropped', listener: (data?: BackpressureThresholdEvent | OperationDroppedEvent) => void): () => void;
+    /**
+     * Execute an entry processor on a single key atomically.
+     *
+     * Entry processors solve the read-modify-write race condition by executing
+     * user-defined logic atomically on the server where the data lives.
+     *
+     * @param mapName Name of the map
+     * @param key Key to process
+     * @param processor Processor definition with name, code, and optional args
+     * @returns Promise resolving to the processor result
+     *
+     * @example
+     * ```typescript
+     * // Increment a counter atomically
+     * const result = await client.executeOnKey('stats', 'pageViews', {
+     *   name: 'increment',
+     *   code: `
+     *     const current = value ?? 0;
+     *     return { value: current + 1, result: current + 1 };
+     *   `,
+     * });
+     *
+     * // Using built-in processor
+     * import { BuiltInProcessors } from '@topgunbuild/core';
+     * const result = await client.executeOnKey(
+     *   'stats',
+     *   'pageViews',
+     *   BuiltInProcessors.INCREMENT(1)
+     * );
+     * ```
+     */
+    executeOnKey<V, R = V>(mapName: string, key: string, processor: EntryProcessorDef<V, R>): Promise<EntryProcessorResult<R>>;
+    /**
+     * Execute an entry processor on multiple keys.
+     *
+     * Each key is processed atomically. The operation returns when all keys
+     * have been processed.
+     *
+     * @param mapName Name of the map
+     * @param keys Keys to process
+     * @param processor Processor definition
+     * @returns Promise resolving to a map of key -> result
+     *
+     * @example
+     * ```typescript
+     * // Reset multiple counters
+     * const results = await client.executeOnKeys(
+     *   'stats',
+     *   ['pageViews', 'uniqueVisitors', 'bounceRate'],
+     *   {
+     *     name: 'reset',
+     *     code: `return { value: 0, result: value };`, // Returns old value
+     *   }
+     * );
+     *
+     * for (const [key, result] of results) {
+     *   console.log(`${key}: was ${result.result}, now 0`);
+     * }
+     * ```
+     */
+    executeOnKeys<V, R = V>(mapName: string, keys: string[], processor: EntryProcessorDef<V, R>): Promise<Map<string, EntryProcessorResult<R>>>;
+    /** Cached EventJournalReader instance */
+    private journalReader?;
+    /**
+     * Get the Event Journal reader for subscribing to and reading
+     * map change events.
+     *
+     * The Event Journal provides:
+     * - Append-only log of all map changes (PUT, UPDATE, DELETE)
+     * - Subscription to real-time events
+     * - Historical event replay
+     * - Audit trail for compliance
+     *
+     * @returns EventJournalReader instance
+     *
+     * @example
+     * ```typescript
+     * const journal = client.getEventJournal();
+     *
+     * // Subscribe to all events
+     * const unsubscribe = journal.subscribe((event) => {
+     *   console.log(`${event.type} on ${event.mapName}:${event.key}`);
+     * });
+     *
+     * // Subscribe to specific map
+     * journal.subscribe(
+     *   (event) => console.log('User changed:', event.key),
+     *   { mapName: 'users' }
+     * );
+     *
+     * // Read historical events
+     * const events = await journal.readFrom(0n, 100);
+     * ```
+     */
+    getEventJournal(): EventJournalReader;
+    /**
+     * Get the conflict resolver client for registering custom merge resolvers.
+     *
+     * Conflict resolvers allow you to customize how merge conflicts are handled
+     * on the server. You can implement business logic like:
+     * - First-write-wins for booking systems
+     * - Numeric constraints (non-negative, min/max)
+     * - Owner-only modifications
+     * - Custom merge strategies
+     *
+     * @returns ConflictResolverClient instance
+     *
+     * @example
+     * ```typescript
+     * const resolvers = client.getConflictResolvers();
+     *
+     * // Register a first-write-wins resolver
+     * await resolvers.register('bookings', {
+     *   name: 'first-write-wins',
+     *   code: `
+     *     if (context.localValue !== undefined) {
+     *       return { action: 'reject', reason: 'Slot already booked' };
+     *     }
+     *     return { action: 'accept', value: context.remoteValue };
+     *   `,
+     *   priority: 100,
+     * });
+     *
+     * // Subscribe to merge rejections
+     * resolvers.onRejection((rejection) => {
+     *   console.log(`Merge rejected: ${rejection.reason}`);
+     *   // Optionally refresh local state
+     * });
+     *
+     * // List registered resolvers
+     * const registered = await resolvers.list('bookings');
+     * console.log('Active resolvers:', registered);
+     *
+     * // Unregister when done
+     * await resolvers.unregister('bookings', 'first-write-wins');
+     * ```
+     */
+    getConflictResolvers(): ConflictResolverClient;
 }
 
 interface TopGunConfig {
@@ -1603,4 +2254,4 @@ declare class SingleServerProvider implements IConnectionProvider {
 
 declare const logger: pino.Logger<never, boolean>;
 
-export { type BackoffConfig, type BackpressureConfig, BackpressureError, type BackpressureStatus, type BackpressureStrategy, type BackpressureThresholdEvent, type CircuitState, ClusterClient, type ClusterClientEvents, type ClusterRoutingMode, type ConnectionEventHandler, ConnectionPool, type ConnectionPoolEvents, type ConnectionProviderEvent, DEFAULT_BACKPRESSURE_CONFIG, DEFAULT_CLUSTER_CONFIG, EncryptedStorageAdapter, type HeartbeatConfig, type IConnectionProvider, IDBAdapter, type IStorageAdapter, type OpLogEntry, type OperationDroppedEvent, PartitionRouter, type PartitionRouterEvents, type QueryFilter, QueryHandle, type QueryResultItem, type QueryResultSource, type RoutingMetrics, type RoutingResult, SingleServerProvider, type SingleServerProviderConfig, type StateChangeEvent, type StateChangeListener, SyncEngine, type SyncEngineConfig, SyncState, SyncStateMachine, type SyncStateMachineConfig, TopGun, TopGunClient, type TopGunClientConfig, type TopGunClusterConfig, type TopicCallback, TopicHandle, VALID_TRANSITIONS, isValidTransition, logger };
+export { type BackoffConfig, type BackpressureConfig, BackpressureError, type BackpressureStatus, type BackpressureStrategy, type BackpressureThresholdEvent, type ChangeEvent, ChangeTracker, type CircuitState, ClusterClient, type ClusterClientEvents, type ClusterRoutingMode, ConflictResolverClient, type ConnectionEventHandler, ConnectionPool, type ConnectionPoolEvents, type ConnectionProviderEvent, DEFAULT_BACKPRESSURE_CONFIG, DEFAULT_CLUSTER_CONFIG, EncryptedStorageAdapter, EventJournalReader, type HeartbeatConfig, type IConnectionProvider, IDBAdapter, type IStorageAdapter, type JournalEventData, type JournalSubscribeOptions, type OpLogEntry, type OperationDroppedEvent, PNCounterHandle, PartitionRouter, type PartitionRouterEvents, type QueryFilter, QueryHandle, type QueryResultItem, type QueryResultSource, type RegisterResult, type ResolverInfo, type RoutingMetrics, type RoutingResult, SingleServerProvider, type SingleServerProviderConfig, type StateChangeEvent, type StateChangeListener, SyncEngine, type SyncEngineConfig, SyncState, SyncStateMachine, type SyncStateMachineConfig, TopGun, TopGunClient, type TopGunClientConfig, type TopGunClusterConfig, type TopicCallback, TopicHandle, VALID_TRANSITIONS, isValidTransition, logger };