@topgunbuild/core 0.3.0 → 0.4.0

package/dist/index.d.ts

@@ -402,6 +402,706 @@ declare function hashORMapRecord<V>(record: ORMapRecord<V>): number;
  */
 declare function compareTimestamps(a: Timestamp, b: Timestamp): number;
 
+/**
+ * State of a PN Counter CRDT.
+ * Tracks positive and negative increments per node for convergence.
+ */
+interface PNCounterState {
+    /** Positive increments per node */
+    positive: Map<string, number>;
+    /** Negative increments per node */
+    negative: Map<string, number>;
+}
+/**
+ * Serializable form of PNCounterState for network/storage.
+ */
+interface PNCounterStateObject {
+    /** Positive increments per node as object */
+    p: Record<string, number>;
+    /** Negative increments per node as object */
+    n: Record<string, number>;
+}
+/**
+ * Configuration for creating a PN Counter.
+ */
+interface PNCounterConfig {
+    /** Unique node identifier for this counter instance */
+    nodeId: string;
+    /** Initial state to restore from */
+    initialState?: PNCounterState;
+}
+/**
+ * Interface for PN Counter CRDT.
+ */
+interface PNCounter {
+    /** Get current value */
+    get(): number;
+    /** Increment by 1, return new value */
+    increment(): number;
+    /** Decrement by 1, return new value */
+    decrement(): number;
+    /** Add delta (positive or negative), 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;
+}
+/**
+ * Positive-Negative Counter CRDT implementation.
+ *
+ * A PN Counter is a CRDT that supports increment and decrement operations
+ * on any node, works offline, and guarantees convergence without coordination.
+ *
+ * How it works:
+ * - Tracks positive increments per node in a G-Counter
+ * - Tracks negative increments per node in another G-Counter
+ * - Value = sum(positive) - sum(negative)
+ * - Merge takes max for each node in both counters
+ *
+ * @example
+ * ```typescript
+ * const counter = new PNCounterImpl({ nodeId: 'node-1' });
+ * counter.increment(); // 1
+ * counter.increment(); // 2
+ * counter.decrement(); // 1
+ * counter.addAndGet(5); // 6
+ * ```
+ */
+declare class PNCounterImpl implements PNCounter {
+    private readonly nodeId;
+    private state;
+    private listeners;
+    constructor(config: PNCounterConfig);
+    /**
+     * Get the current counter value.
+     * Value = sum(positive) - sum(negative)
+     */
+    get(): number;
+    /**
+     * Increment by 1 and return the new value.
+     */
+    increment(): number;
+    /**
+     * Decrement by 1 and return the new value.
+     */
+    decrement(): number;
+    /**
+     * Add a delta (positive or negative) and return the new value.
+     * @param delta The amount to add (can be negative)
+     */
+    addAndGet(delta: number): number;
+    /**
+     * Get a copy of the current state for synchronization.
+     */
+    getState(): PNCounterState;
+    /**
+     * Merge remote state into this counter.
+     * Takes the maximum value for each node in both positive and negative counters.
+     * This operation is commutative, associative, and idempotent (CRDT properties).
+     *
+     * @param remote The remote state to merge
+     */
+    merge(remote: PNCounterState): void;
+    /**
+     * Subscribe to value changes.
+     * The listener is immediately called with the current value.
+     *
+     * @param listener Callback function receiving the new value
+     * @returns Unsubscribe function
+     */
+    subscribe(listener: (value: number) => void): () => void;
+    private notifyListeners;
+    /**
+     * Get the node ID of this counter instance.
+     */
+    getNodeId(): string;
+    /**
+     * Serialize state to binary format (msgpack).
+     */
+    static serialize(state: PNCounterState): Uint8Array;
+    /**
+     * Deserialize binary data to state.
+     */
+    static deserialize(data: Uint8Array): PNCounterState;
+    /**
+     * Convert state to plain object (for JSON/network).
+     */
+    static stateToObject(state: PNCounterState): PNCounterStateObject;
+    /**
+     * Convert plain object to state.
+     */
+    static objectToState(obj: PNCounterStateObject): PNCounterState;
+}
+
+/**
+ * Fixed-size circular buffer with sequence numbers.
+ * Older entries are overwritten when capacity is reached.
+ *
+ * @template T - Type of items stored in the buffer
+ */
+declare class Ringbuffer<T> {
+    private buffer;
+    private readonly _capacity;
+    private headSequence;
+    private tailSequence;
+    constructor(capacity: number);
+    /**
+     * Add item to buffer, returns sequence number.
+     */
+    add(item: T): bigint;
+    /**
+     * Read item at sequence.
+     * Returns undefined if sequence is out of range.
+     */
+    read(sequence: bigint): T | undefined;
+    /**
+     * Read range of items (inclusive).
+     * Automatically clamps to available range.
+     */
+    readRange(startSeq: bigint, endSeq: bigint): T[];
+    /**
+     * Read from sequence with limit.
+     */
+    readFrom(startSeq: bigint, limit?: number): T[];
+    /**
+     * Get the oldest available sequence number.
+     */
+    getHeadSequence(): bigint;
+    /**
+     * Get the next sequence number to be written.
+     */
+    getTailSequence(): bigint;
+    /**
+     * Get the number of items currently in the buffer.
+     */
+    size(): number;
+    /**
+     * Get the maximum capacity of the buffer.
+     */
+    getCapacity(): number;
+    /**
+     * Clear all items from the buffer.
+     */
+    clear(): void;
+    /**
+     * Check if a sequence is available in the buffer.
+     */
+    isAvailable(sequence: bigint): boolean;
+    /**
+     * Get remaining capacity before oldest entries are overwritten.
+     */
+    remainingCapacity(): number;
+}
+
+/**
+ * Type of journal event.
+ */
+type JournalEventType = 'PUT' | 'UPDATE' | 'DELETE';
+/**
+ * Single event in the journal.
+ */
+interface JournalEvent<V = unknown> {
+    /** Monotonically increasing sequence number */
+    sequence: bigint;
+    /** Event type */
+    type: JournalEventType;
+    /** Map name */
+    mapName: string;
+    /** Entry key */
+    key: string;
+    /** New value (undefined for DELETE) */
+    value?: V;
+    /** Previous value (for UPDATE and DELETE) */
+    previousValue?: V;
+    /** HLC timestamp */
+    timestamp: Timestamp;
+    /** Node that made the change */
+    nodeId: string;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for appending events (without sequence).
+ */
+type JournalEventInput<V = unknown> = Omit<JournalEvent<V>, 'sequence'>;
+/**
+ * Event Journal configuration.
+ */
+interface EventJournalConfig {
+    /** Maximum number of events to keep in memory */
+    capacity: number;
+    /** Time-to-live for events (ms), 0 = infinite */
+    ttlMs: number;
+    /** Persist to storage adapter */
+    persistent: boolean;
+    /** Maps to include (empty = all) */
+    includeMaps?: string[];
+    /** Maps to exclude */
+    excludeMaps?: string[];
+}
+/**
+ * Default configuration for Event Journal.
+ */
+declare const DEFAULT_EVENT_JOURNAL_CONFIG: EventJournalConfig;
+/**
+ * Event Journal interface.
+ */
+interface EventJournal {
+    /** Append event to journal */
+    append<V>(event: JournalEventInput<V>): JournalEvent<V>;
+    /** Read events from sequence (inclusive) */
+    readFrom(sequence: bigint, limit?: number): JournalEvent[];
+    /** Read events in range */
+    readRange(startSeq: bigint, endSeq: bigint): JournalEvent[];
+    /** Get latest sequence number */
+    getLatestSequence(): bigint;
+    /** Get oldest sequence number (after compaction) */
+    getOldestSequence(): bigint;
+    /** Subscribe to new events */
+    subscribe(listener: (event: JournalEvent) => void, fromSequence?: bigint): () => void;
+    /** Get capacity info */
+    getCapacity(): {
+        used: number;
+        total: number;
+    };
+    /** Force compaction */
+    compact(): Promise<void>;
+    /** Dispose resources */
+    dispose(): void;
+}
+/**
+ * Journal event listener type.
+ */
+type JournalEventListener = (event: JournalEvent) => void;
+/**
+ * Event Journal implementation using Ringbuffer.
+ * Records all Map changes as an append-only log.
+ */
+declare class EventJournalImpl implements EventJournal {
+    private readonly config;
+    private readonly buffer;
+    private readonly listeners;
+    private ttlTimer?;
+    constructor(config?: Partial<EventJournalConfig>);
+    /**
+     * Append event to journal.
+     * Returns the event with assigned sequence number.
+     * Returns event with sequence -1n if map is filtered out.
+     */
+    append<V>(eventData: JournalEventInput<V>): JournalEvent<V>;
+    /**
+     * Read events from sequence with optional limit.
+     */
+    readFrom(sequence: bigint, limit?: number): JournalEvent[];
+    /**
+     * Read events in range (inclusive).
+     */
+    readRange(startSeq: bigint, endSeq: bigint): JournalEvent[];
+    /**
+     * Get latest sequence number.
+     * Returns 0n if no events have been added.
+     */
+    getLatestSequence(): bigint;
+    /**
+     * Get oldest available sequence number.
+     */
+    getOldestSequence(): bigint;
+    /**
+     * Subscribe to new events.
+     * Optionally replay events from a specific sequence.
+     *
+     * @param listener Callback for each event
+     * @param fromSequence Optional sequence to start replay from
+     * @returns Unsubscribe function
+     */
+    subscribe(listener: JournalEventListener, fromSequence?: bigint): () => void;
+    /**
+     * Get capacity information.
+     */
+    getCapacity(): {
+        used: number;
+        total: number;
+    };
+    /**
+     * Force compaction.
+     * Note: The ringbuffer handles eviction automatically.
+     * This method is provided for explicit cleanup of old events.
+     */
+    compact(): Promise<void>;
+    /**
+     * Check if a map should be captured.
+     */
+    private shouldCapture;
+    /**
+     * Start TTL cleanup timer.
+     */
+    private startTTLCleanup;
+    /**
+     * Dispose resources.
+     */
+    dispose(): void;
+    /**
+     * Get all current listeners count (for testing).
+     */
+    getListenerCount(): number;
+    /**
+     * Get configuration (for testing).
+     */
+    getConfig(): EventJournalConfig;
+}
+
+/**
+ * Function executed on the server against a single entry.
+ * Receives the current value (or undefined if key doesn't exist).
+ * Returns the new value (or undefined to delete the entry).
+ */
+type EntryProcessorFn<V, R = V> = (value: V | undefined, key: string, args?: unknown) => {
+    value: V | undefined;
+    result?: R;
+};
+/**
+ * Zod schema for entry processor definition validation.
+ */
+declare const EntryProcessorDefSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    args: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Serializable entry processor definition.
+ * Code is sent as string and executed in isolated sandbox.
+ */
+interface EntryProcessorDef<V = unknown, R = V> {
+    /** Unique processor name for caching compiled code */
+    name: string;
+    /** JavaScript function body as string */
+    code: string;
+    /** Optional arguments passed to the processor */
+    args?: unknown;
+    /** Type markers (not serialized) */
+    __valueType?: V;
+    __resultType?: R;
+}
+/**
+ * Result of entry processor execution.
+ */
+interface EntryProcessorResult<R = unknown> {
+    /** Whether the operation succeeded */
+    success: boolean;
+    /** Custom result returned by processor */
+    result?: R;
+    /** Error message if failed */
+    error?: string;
+    /** New value after processing (for client cache update) */
+    newValue?: unknown;
+}
+/**
+ * Patterns that are denied in processor code for security reasons.
+ */
+declare const FORBIDDEN_PATTERNS: RegExp[];
+/**
+ * Validates processor code against forbidden patterns.
+ * Returns true if code is safe, false otherwise.
+ */
+declare function validateProcessorCode(code: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Built-in processors for common operations.
+ * These are type-safe and pre-validated.
+ */
+declare const BuiltInProcessors: {
+    /**
+     * Increment numeric value by delta.
+     * If value doesn't exist, starts from 0.
+     */
+    INCREMENT: (delta?: number) => EntryProcessorDef<number, number>;
+    /**
+     * Decrement numeric value by delta.
+     * If value doesn't exist, starts from 0.
+     */
+    DECREMENT: (delta?: number) => EntryProcessorDef<number, number>;
+    /**
+     * Decrement with floor (won't go below 0).
+     * Returns both the new value and whether it was floored.
+     */
+    DECREMENT_FLOOR: (delta?: number) => EntryProcessorDef<number, {
+        newValue: number;
+        wasFloored: boolean;
+    }>;
+    /**
+     * Multiply numeric value by factor.
+     * If value doesn't exist, starts from 1.
+     */
+    MULTIPLY: (factor: number) => EntryProcessorDef<number, number>;
+    /**
+     * Set value only if key doesn't exist.
+     * Returns true if value was set, false if key already existed.
+     */
+    PUT_IF_ABSENT: <V>(newValue: V) => EntryProcessorDef<V, boolean>;
+    /**
+     * Replace value only if key exists.
+     * Returns the old value if replaced, undefined otherwise.
+     */
+    REPLACE: <V>(newValue: V) => EntryProcessorDef<V, V | undefined>;
+    /**
+     * Replace value only if it matches expected value.
+     * Returns true if replaced, false otherwise.
+     */
+    REPLACE_IF_EQUALS: <V>(expectedValue: V, newValue: V) => EntryProcessorDef<V, boolean>;
+    /**
+     * Delete entry only if value matches.
+     * Returns true if deleted, false otherwise.
+     */
+    DELETE_IF_EQUALS: <V>(expectedValue: V) => EntryProcessorDef<V, boolean>;
+    /**
+     * Append item to array.
+     * Creates array if it doesn't exist.
+     * Returns new array length.
+     */
+    ARRAY_PUSH: <T>(item: T) => EntryProcessorDef<T[], number>;
+    /**
+     * Remove last item from array.
+     * Returns the removed item or undefined.
+     */
+    ARRAY_POP: <T>() => EntryProcessorDef<T[], T | undefined>;
+    /**
+     * Remove item from array by value (first occurrence).
+     * Returns true if item was found and removed.
+     */
+    ARRAY_REMOVE: <T>(item: T) => EntryProcessorDef<T[], boolean>;
+    /**
+     * Update nested property using dot notation path.
+     * Creates intermediate objects if they don't exist.
+     */
+    SET_PROPERTY: <V>(path: string, propValue: unknown) => EntryProcessorDef<V, V>;
+    /**
+     * Delete nested property using dot notation path.
+     * Returns the deleted value or undefined.
+     */
+    DELETE_PROPERTY: <V>(path: string) => EntryProcessorDef<V, unknown>;
+    /**
+     * Get current value without modifying it.
+     * Useful for conditional reads.
+     */
+    GET: <V>() => EntryProcessorDef<V, V | undefined>;
+    /**
+     * Conditional update based on version/timestamp.
+     * Only updates if current version matches expected.
+     * Useful for optimistic locking.
+     */
+    CONDITIONAL_UPDATE: <V extends {
+        version?: number;
+    }>(expectedVersion: number, newData: Partial<V>) => EntryProcessorDef<V, {
+        updated: boolean;
+        conflict: boolean;
+    }>;
+    /**
+     * Merge object properties into existing value.
+     * Shallow merge only.
+     */
+    MERGE: <V extends Record<string, unknown>>(properties: Partial<V>) => EntryProcessorDef<V, V>;
+};
+/**
+ * Rate limiting configuration for processor execution.
+ */
+interface ProcessorRateLimitConfig {
+    /** Max processor executions per second per client */
+    maxExecutionsPerSecond: number;
+    /** Max processor code size in bytes */
+    maxCodeSizeBytes: number;
+    /** Max args size in bytes (JSON stringified) */
+    maxArgsSizeBytes: number;
+}
+/**
+ * Default rate limit configuration.
+ */
+declare const DEFAULT_PROCESSOR_RATE_LIMITS: ProcessorRateLimitConfig;
+
+/**
+ * Context provided to a conflict resolver during merge operations.
+ */
+interface MergeContext<V = unknown> {
+    /** Map name being modified */
+    mapName: string;
+    /** Entry key being modified */
+    key: string;
+    /** Current server/local value (undefined if key doesn't exist) */
+    localValue: V | undefined;
+    /** Incoming client/remote value */
+    remoteValue: V;
+    /** Local HLC timestamp (undefined if key doesn't exist) */
+    localTimestamp?: Timestamp;
+    /** Remote HLC timestamp */
+    remoteTimestamp: Timestamp;
+    /** Client/node ID that sent the update */
+    remoteNodeId: string;
+    /** Authentication context (optional) */
+    auth?: {
+        userId?: string;
+        roles?: string[];
+        metadata?: Record<string, unknown>;
+    };
+    /** Read other entries for cross-key validation */
+    readEntry: (key: string) => V | undefined;
+}
+/**
+ * Result of conflict resolution.
+ */
+type MergeResult<V = unknown> = {
+    action: 'accept';
+    value: V;
+} | {
+    action: 'reject';
+    reason: string;
+} | {
+    action: 'merge';
+    value: V;
+} | {
+    action: 'local';
+};
+/**
+ * Conflict resolver function signature.
+ */
+type ConflictResolverFn<V = unknown> = (context: MergeContext<V>) => MergeResult<V> | Promise<MergeResult<V>>;
+/**
+ * Conflict resolver definition (can be native function or sandboxed code).
+ */
+interface ConflictResolverDef<V = unknown> {
+    /** Unique resolver name */
+    name: string;
+    /** JavaScript function body as string (for sandboxed execution) */
+    code?: string;
+    /** Native function (for trusted server-side resolvers) */
+    fn?: ConflictResolverFn<V>;
+    /** Priority (higher = runs first, default 50) */
+    priority?: number;
+    /** Apply only to specific keys (glob pattern) */
+    keyPattern?: string;
+}
+/**
+ * Zod schema for validating conflict resolver definitions from network.
+ */
+declare const ConflictResolverDefSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    keyPattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Patterns that are denied in resolver code for security reasons.
+ * Same patterns as EntryProcessor for consistency.
+ */
+declare const RESOLVER_FORBIDDEN_PATTERNS: RegExp[];
+/**
+ * Validates resolver code against forbidden patterns.
+ */
+declare function validateResolverCode(code: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Rate limiting configuration for resolver registration.
+ */
+interface ResolverRateLimitConfig {
+    /** Max resolver registrations per client */
+    maxResolversPerClient: number;
+    /** Max resolver code size in bytes */
+    maxCodeSizeBytes: number;
+}
+/**
+ * Default rate limit configuration.
+ */
+declare const DEFAULT_RESOLVER_RATE_LIMITS: ResolverRateLimitConfig;
+/**
+ * Compares two HLC timestamps.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ */
+declare function compareHLCTimestamps(a: Timestamp, b: Timestamp): number;
+/**
+ * Deep merges two objects.
+ * Remote values take precedence at each level.
+ */
+declare function deepMerge<T extends object>(target: T, source: T): T;
+/**
+ * Built-in conflict resolvers for common patterns.
+ * These are type-safe and pre-validated.
+ */
+declare const BuiltInResolvers: {
+    /**
+     * Standard Last-Write-Wins - accept if remote timestamp is newer.
+     */
+    LWW: <V>() => ConflictResolverDef<V>;
+    /**
+     * First-Write-Wins - reject if local value exists.
+     * Useful for booking systems, unique constraints.
+     */
+    FIRST_WRITE_WINS: <V>() => ConflictResolverDef<V>;
+    /**
+     * Numeric minimum - keep lowest value.
+     * Useful for auction systems (lowest bid wins).
+     */
+    NUMERIC_MIN: () => ConflictResolverDef<number>;
+    /**
+     * Numeric maximum - keep highest value.
+     * Useful for high score tracking.
+     */
+    NUMERIC_MAX: () => ConflictResolverDef<number>;
+    /**
+     * Non-negative - reject if value would be negative.
+     * Useful for inventory systems.
+     */
+    NON_NEGATIVE: () => ConflictResolverDef<number>;
+    /**
+     * Array union - merge arrays by taking union of elements.
+     * Useful for tags, categories.
+     */
+    ARRAY_UNION: <T>() => ConflictResolverDef<T[]>;
+    /**
+     * Deep merge - recursively merge objects.
+     * Remote values take precedence at leaf level.
+     */
+    DEEP_MERGE: <V extends object>() => ConflictResolverDef<V>;
+    /**
+     * Server-only - reject all client writes.
+     * Useful for server-controlled state.
+     */
+    SERVER_ONLY: <V>() => ConflictResolverDef<V>;
+    /**
+     * Owner-only - only the original creator can modify.
+     * Requires value to have an `ownerId` property.
+     */
+    OWNER_ONLY: <V extends {
+        ownerId?: string;
+    }>() => ConflictResolverDef<V>;
+    /**
+     * Immutable - reject any modifications after initial write.
+     */
+    IMMUTABLE: <V>() => ConflictResolverDef<V>;
+    /**
+     * Version check - only accept if version increments by 1.
+     * Useful for optimistic locking.
+     */
+    VERSION_INCREMENT: <V extends {
+        version?: number;
+    }>() => ConflictResolverDef<V>;
+};
+/**
+ * Event emitted when a merge is rejected.
+ */
+interface MergeRejection {
+    mapName: string;
+    key: string;
+    attemptedValue: unknown;
+    reason: string;
+    timestamp: Timestamp;
+    nodeId: string;
+}
+
 /**
  * Hash utilities for TopGun
  *
@@ -796,6 +1496,46 @@ declare const TopicMessageEventSchema: z.ZodObject<{
         timestamp: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
+declare const PNCounterStateObjectSchema: z.ZodObject<{
+    p: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    n: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+declare const CounterRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"COUNTER_REQUEST">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const CounterSyncSchema: z.ZodObject<{
+    type: z.ZodLiteral<"COUNTER_SYNC">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodObject<{
+            p: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            n: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const CounterResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"COUNTER_RESPONSE">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodObject<{
+            p: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            n: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const CounterUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"COUNTER_UPDATE">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodObject<{
+            p: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            n: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 declare const PingMessageSchema: z.ZodObject<{
     type: z.ZodLiteral<"PING">;
     timestamp: z.ZodNumber;
@@ -951,6 +1691,274 @@ declare const PartitionMapRequestSchema: z.ZodObject<{
         currentVersion: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * Entry processor definition schema.
+ */
+declare const EntryProcessorSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    args: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * ENTRY_PROCESS: Client requests atomic operation on single key.
+ */
+declare const EntryProcessRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    key: z.ZodString;
+    processor: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * ENTRY_PROCESS_BATCH: Client requests atomic operation on multiple keys.
+ */
+declare const EntryProcessBatchRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS_BATCH">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    keys: z.ZodArray<z.ZodString>;
+    processor: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * ENTRY_PROCESS_RESPONSE: Server responds to single-key processor request.
+ */
+declare const EntryProcessResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS_RESPONSE">;
+    requestId: z.ZodString;
+    success: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodUnknown>;
+    newValue: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Individual key result in batch response.
+ */
+declare const EntryProcessKeyResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodUnknown>;
+    newValue: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * ENTRY_PROCESS_BATCH_RESPONSE: Server responds to multi-key processor request.
+ */
+declare const EntryProcessBatchResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS_BATCH_RESPONSE">;
+    requestId: z.ZodString;
+    results: z.ZodRecord<z.ZodString, z.ZodObject<{
+        success: z.ZodBoolean;
+        result: z.ZodOptional<z.ZodUnknown>;
+        newValue: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Journal event type schema.
+ */
+declare const JournalEventTypeSchema: z.ZodEnum<{
+    PUT: "PUT";
+    UPDATE: "UPDATE";
+    DELETE: "DELETE";
+}>;
+/**
+ * Journal event data (serialized for network).
+ */
+declare const JournalEventDataSchema: z.ZodObject<{
+    sequence: z.ZodString;
+    type: z.ZodEnum<{
+        PUT: "PUT";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+    }>;
+    mapName: z.ZodString;
+    key: z.ZodString;
+    value: z.ZodOptional<z.ZodUnknown>;
+    previousValue: z.ZodOptional<z.ZodUnknown>;
+    timestamp: z.ZodObject<{
+        millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+        counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    nodeId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * JOURNAL_SUBSCRIBE: Client subscribes to journal events.
+ */
+declare const JournalSubscribeRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_SUBSCRIBE">;
+    requestId: z.ZodString;
+    fromSequence: z.ZodOptional<z.ZodString>;
+    mapName: z.ZodOptional<z.ZodString>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        PUT: "PUT";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * JOURNAL_UNSUBSCRIBE: Client unsubscribes from journal events.
+ */
+declare const JournalUnsubscribeRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_UNSUBSCRIBE">;
+    subscriptionId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * JOURNAL_EVENT: Server sends journal event to client.
+ */
+declare const JournalEventMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_EVENT">;
+    event: z.ZodObject<{
+        sequence: z.ZodString;
+        type: z.ZodEnum<{
+            PUT: "PUT";
+            UPDATE: "UPDATE";
+            DELETE: "DELETE";
+        }>;
+        mapName: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodUnknown>;
+        previousValue: z.ZodOptional<z.ZodUnknown>;
+        timestamp: z.ZodObject<{
+            millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+        nodeId: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * JOURNAL_READ: Client requests events from journal.
+ */
+declare const JournalReadRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_READ">;
+    requestId: z.ZodString;
+    fromSequence: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mapName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * JOURNAL_READ_RESPONSE: Server responds with journal events.
+ */
+declare const JournalReadResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_READ_RESPONSE">;
+    requestId: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodString;
+        type: z.ZodEnum<{
+            PUT: "PUT";
+            UPDATE: "UPDATE";
+            DELETE: "DELETE";
+        }>;
+        mapName: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodUnknown>;
+        previousValue: z.ZodOptional<z.ZodUnknown>;
+        timestamp: z.ZodObject<{
+            millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+        nodeId: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Conflict resolver definition schema (wire format).
+ */
+declare const ConflictResolverSchema: z.ZodObject<{
+    name: z.ZodString;
+    code: z.ZodString;
+    priority: z.ZodOptional<z.ZodNumber>;
+    keyPattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * REGISTER_RESOLVER: Client registers a conflict resolver on server.
+ */
+declare const RegisterResolverRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"REGISTER_RESOLVER">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    resolver: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodString;
+        priority: z.ZodOptional<z.ZodNumber>;
+        keyPattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * REGISTER_RESOLVER_RESPONSE: Server acknowledges resolver registration.
+ */
+declare const RegisterResolverResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"REGISTER_RESOLVER_RESPONSE">;
+    requestId: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * UNREGISTER_RESOLVER: Client unregisters a conflict resolver.
+ */
+declare const UnregisterResolverRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"UNREGISTER_RESOLVER">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    resolverName: z.ZodString;
+}, z.core.$strip>;
+/**
+ * UNREGISTER_RESOLVER_RESPONSE: Server acknowledges resolver unregistration.
+ */
+declare const UnregisterResolverResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"UNREGISTER_RESOLVER_RESPONSE">;
+    requestId: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * MERGE_REJECTED: Server notifies client that a merge was rejected.
+ */
+declare const MergeRejectedMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"MERGE_REJECTED">;
+    mapName: z.ZodString;
+    key: z.ZodString;
+    attemptedValue: z.ZodUnknown;
+    reason: z.ZodString;
+    timestamp: z.ZodObject<{
+        millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+        counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * LIST_RESOLVERS: Client requests list of registered resolvers.
+ */
+declare const ListResolversRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"LIST_RESOLVERS">;
+    requestId: z.ZodString;
+    mapName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * LIST_RESOLVERS_RESPONSE: Server responds with registered resolvers.
+ */
+declare const ListResolversResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"LIST_RESOLVERS_RESPONSE">;
+    requestId: z.ZodString;
+    resolvers: z.ZodArray<z.ZodObject<{
+        mapName: z.ZodString;
+        name: z.ZodString;
+        priority: z.ZodOptional<z.ZodNumber>;
+        keyPattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 /**
  * Individual operation result within a batch ACK
  */
@@ -1294,6 +2302,168 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     payload: z.ZodOptional<z.ZodObject<{
         currentVersion: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"COUNTER_REQUEST">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"COUNTER_SYNC">;
+    payload: z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodObject<{
+            p: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            n: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    key: z.ZodString;
+    processor: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS_BATCH">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    keys: z.ZodArray<z.ZodString>;
+    processor: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodString;
+        args: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS_RESPONSE">;
+    requestId: z.ZodString;
+    success: z.ZodBoolean;
+    result: z.ZodOptional<z.ZodUnknown>;
+    newValue: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ENTRY_PROCESS_BATCH_RESPONSE">;
+    requestId: z.ZodString;
+    results: z.ZodRecord<z.ZodString, z.ZodObject<{
+        success: z.ZodBoolean;
+        result: z.ZodOptional<z.ZodUnknown>;
+        newValue: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_SUBSCRIBE">;
+    requestId: z.ZodString;
+    fromSequence: z.ZodOptional<z.ZodString>;
+    mapName: z.ZodOptional<z.ZodString>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        PUT: "PUT";
+        UPDATE: "UPDATE";
+        DELETE: "DELETE";
+    }>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_UNSUBSCRIBE">;
+    subscriptionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_EVENT">;
+    event: z.ZodObject<{
+        sequence: z.ZodString;
+        type: z.ZodEnum<{
+            PUT: "PUT";
+            UPDATE: "UPDATE";
+            DELETE: "DELETE";
+        }>;
+        mapName: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodUnknown>;
+        previousValue: z.ZodOptional<z.ZodUnknown>;
+        timestamp: z.ZodObject<{
+            millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+        nodeId: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_READ">;
+    requestId: z.ZodString;
+    fromSequence: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mapName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"JOURNAL_READ_RESPONSE">;
+    requestId: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodString;
+        type: z.ZodEnum<{
+            PUT: "PUT";
+            UPDATE: "UPDATE";
+            DELETE: "DELETE";
+        }>;
+        mapName: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodOptional<z.ZodUnknown>;
+        previousValue: z.ZodOptional<z.ZodUnknown>;
+        timestamp: z.ZodObject<{
+            millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+        nodeId: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"REGISTER_RESOLVER">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    resolver: z.ZodObject<{
+        name: z.ZodString;
+        code: z.ZodString;
+        priority: z.ZodOptional<z.ZodNumber>;
+        keyPattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"REGISTER_RESOLVER_RESPONSE">;
+    requestId: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"UNREGISTER_RESOLVER">;
+    requestId: z.ZodString;
+    mapName: z.ZodString;
+    resolverName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"UNREGISTER_RESOLVER_RESPONSE">;
+    requestId: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"MERGE_REJECTED">;
+    mapName: z.ZodString;
+    key: z.ZodString;
+    attemptedValue: z.ZodUnknown;
+    reason: z.ZodString;
+    timestamp: z.ZodObject<{
+        millis: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+        counter: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt]>, z.ZodTransform<number, number | bigint>>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"LIST_RESOLVERS">;
+    requestId: z.ZodString;
+    mapName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"LIST_RESOLVERS_RESPONSE">;
+    requestId: z.ZodString;
+    resolvers: z.ZodArray<z.ZodObject<{
+        mapName: z.ZodString;
+        name: z.ZodString;
+        priority: z.ZodOptional<z.ZodNumber>;
+        keyPattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>], "type">;
 type Query = z.infer<typeof QuerySchema>;
 type ClientOp = z.infer<typeof ClientOpSchema>;
@@ -1304,6 +2474,25 @@ type BatchMessage = z.infer<typeof BatchMessageSchema>;
 type OpAckMessage = z.infer<typeof OpAckMessageSchema>;
 type OpRejectedMessage = z.infer<typeof OpRejectedMessageSchema>;
 type OpResult = z.infer<typeof OpResultSchema>;
+type EntryProcessRequest = z.infer<typeof EntryProcessRequestSchema>;
+type EntryProcessBatchRequest = z.infer<typeof EntryProcessBatchRequestSchema>;
+type EntryProcessResponse = z.infer<typeof EntryProcessResponseSchema>;
+type EntryProcessBatchResponse = z.infer<typeof EntryProcessBatchResponseSchema>;
+type EntryProcessKeyResult = z.infer<typeof EntryProcessKeyResultSchema>;
+type JournalEventData = z.infer<typeof JournalEventDataSchema>;
+type JournalSubscribeRequest = z.infer<typeof JournalSubscribeRequestSchema>;
+type JournalUnsubscribeRequest = z.infer<typeof JournalUnsubscribeRequestSchema>;
+type JournalEventMessage = z.infer<typeof JournalEventMessageSchema>;
+type JournalReadRequest = z.infer<typeof JournalReadRequestSchema>;
+type JournalReadResponse = z.infer<typeof JournalReadResponseSchema>;
+type ConflictResolver = z.infer<typeof ConflictResolverSchema>;
+type RegisterResolverRequest = z.infer<typeof RegisterResolverRequestSchema>;
+type RegisterResolverResponse = z.infer<typeof RegisterResolverResponseSchema>;
+type UnregisterResolverRequest = z.infer<typeof UnregisterResolverRequestSchema>;
+type UnregisterResolverResponse = z.infer<typeof UnregisterResolverResponseSchema>;
+type MergeRejectedMessage = z.infer<typeof MergeRejectedMessageSchema>;
+type ListResolversRequest = z.infer<typeof ListResolversRequestSchema>;
+type ListResolversResponse = z.infer<typeof ListResolversResponseSchema>;
 
 /**
  * Write Concern - Configurable Acknowledgment Levels
@@ -1773,4 +2962,4 @@ type ReplicationProtocolMessage = ReplicationMessage | ReplicationBatchMessage |
 declare const PARTITION_COUNT = 271;
 declare const DEFAULT_BACKUP_COUNT = 1;
 
-export { AuthMessageSchema, type BatchMessage, BatchMessageSchema, type CircuitBreakerConfig, type ClientOp, ClientOpMessageSchema, ClientOpSchema, type ClusterClientConfig, type ClusterEvents, type ReadOptions as ClusterReadOptions, type WriteOptions as ClusterWriteOptions, type ConnectionPoolConfig, type ConnectionState, ConsistencyLevel, DEFAULT_BACKUP_COUNT, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_PARTITION_ROUTER_CONFIG, DEFAULT_REPLICATION_CONFIG, DEFAULT_WRITE_CONCERN_TIMEOUT, HLC, LWWMap, type LWWRecord, LWWRecordSchema, LockReleaseSchema, LockRequestSchema, type MergeKeyResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, type MigrationChunkAckMessage, type MigrationChunkMessage, type MigrationCompleteMessage, type MigrationConfig, type MigrationMessage, type MigrationMetrics, type MigrationStartMessage, type MigrationStatus, type MigrationVerifyMessage, type NodeHealth, type NodeInfo, type NodeStatus, type NotOwnerError, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapRecord, ORMapRecordSchema, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, type OpAckMessage, OpAckMessageSchema, OpBatchMessageSchema, type OpRejectedMessage, OpRejectedMessageSchema, type OpResult, OpResultSchema, PARTITION_COUNT, type PartitionChange, type PartitionInfo, type PartitionMap, type PartitionMapDeltaMessage, type PartitionMapMessage, type PartitionMapRequestMessage, PartitionMapRequestSchema, type PartitionMigration, type PartitionRouterConfig, PartitionState, type PendingWrite, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PongMessage, PongMessageSchema, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type Query, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, type ReplicationAckMessage, type ReplicationBatchAckMessage, type ReplicationBatchMessage, type ReplicationConfig, type ReplicationHealth, type ReplicationLag, type ReplicationMessage, type ReplicationProtocolMessage, type ReplicationResult, type ReplicationTask, type RoutingError, type StaleMapError, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type Timestamp, TimestampSchema, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, WRITE_CONCERN_ORDER, WriteConcern, WriteConcernSchema, type WriteConcernValue, type WriteOptions$1 as WriteOptions, type WriteResult, combineHashes, compareTimestamps, deserialize, disableNativeHash, evaluatePredicate, getHighestWriteConcernLevel, hashORMapEntry, hashORMapRecord, hashString, isUsingNativeHash, isWriteConcernAchieved, resetNativeHash, serialize, timestampToString };
+export { AuthMessageSchema, type BatchMessage, BatchMessageSchema, BuiltInProcessors, BuiltInResolvers, type CircuitBreakerConfig, type ClientOp, ClientOpMessageSchema, ClientOpSchema, type ClusterClientConfig, type ClusterEvents, type ReadOptions as ClusterReadOptions, type WriteOptions as ClusterWriteOptions, type ConflictResolver, type ConflictResolverDef, ConflictResolverDefSchema, type ConflictResolverFn, ConflictResolverSchema, type ConnectionPoolConfig, type ConnectionState, ConsistencyLevel, CounterRequestSchema, CounterResponseSchema, CounterSyncSchema, CounterUpdateSchema, DEFAULT_BACKUP_COUNT, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONNECTION_POOL_CONFIG, DEFAULT_EVENT_JOURNAL_CONFIG, DEFAULT_MIGRATION_CONFIG, DEFAULT_PARTITION_ROUTER_CONFIG, DEFAULT_PROCESSOR_RATE_LIMITS, DEFAULT_REPLICATION_CONFIG, DEFAULT_RESOLVER_RATE_LIMITS, DEFAULT_WRITE_CONCERN_TIMEOUT, type EntryProcessBatchRequest, EntryProcessBatchRequestSchema, type EntryProcessBatchResponse, EntryProcessBatchResponseSchema, type EntryProcessKeyResult, EntryProcessKeyResultSchema, type EntryProcessRequest, EntryProcessRequestSchema, type EntryProcessResponse, EntryProcessResponseSchema, type EntryProcessorDef, EntryProcessorDefSchema, type EntryProcessorFn, type EntryProcessorResult, EntryProcessorSchema, type EventJournal, type EventJournalConfig, EventJournalImpl, FORBIDDEN_PATTERNS, HLC, type JournalEvent, type JournalEventData, JournalEventDataSchema, type JournalEventInput, type JournalEventListener, type JournalEventMessage, JournalEventMessageSchema, type JournalEventType, JournalEventTypeSchema, type JournalReadRequest, JournalReadRequestSchema, type JournalReadResponse, JournalReadResponseSchema, type JournalSubscribeRequest, JournalSubscribeRequestSchema, type JournalUnsubscribeRequest, JournalUnsubscribeRequestSchema, LWWMap, type LWWRecord, LWWRecordSchema, type ListResolversRequest, ListResolversRequestSchema, type ListResolversResponse, ListResolversResponseSchema, LockReleaseSchema, LockRequestSchema, type MergeContext, type MergeKeyResult, type MergeRejectedMessage, MergeRejectedMessageSchema, type MergeRejection, type MergeResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, type MigrationChunkAckMessage, type MigrationChunkMessage, type MigrationCompleteMessage, type MigrationConfig, type MigrationMessage, type MigrationMetrics, type MigrationStartMessage, type MigrationStatus, type MigrationVerifyMessage, type NodeHealth, type NodeInfo, type NodeStatus, type NotOwnerError, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapRecord, ORMapRecordSchema, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, type OpAckMessage, OpAckMessageSchema, OpBatchMessageSchema, type OpRejectedMessage, OpRejectedMessageSchema, type OpResult, OpResultSchema, PARTITION_COUNT, type PNCounter, type PNCounterConfig, PNCounterImpl, type PNCounterState, type PNCounterStateObject, PNCounterStateObjectSchema, type PartitionChange, type PartitionInfo, type PartitionMap, type PartitionMapDeltaMessage, type PartitionMapMessage, type PartitionMapRequestMessage, PartitionMapRequestSchema, type PartitionMigration, type PartitionRouterConfig, PartitionState, type PendingWrite, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PongMessage, PongMessageSchema, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type ProcessorRateLimitConfig, type Query, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, RESOLVER_FORBIDDEN_PATTERNS, type RegisterResolverRequest, RegisterResolverRequestSchema, type RegisterResolverResponse, RegisterResolverResponseSchema, type ReplicationAckMessage, type ReplicationBatchAckMessage, type ReplicationBatchMessage, type ReplicationConfig, type ReplicationHealth, type ReplicationLag, type ReplicationMessage, type ReplicationProtocolMessage, type ReplicationResult, type ReplicationTask, type ResolverRateLimitConfig, Ringbuffer, type RoutingError, type StaleMapError, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type Timestamp, TimestampSchema, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, type UnregisterResolverRequest, UnregisterResolverRequestSchema, type UnregisterResolverResponse, UnregisterResolverResponseSchema, WRITE_CONCERN_ORDER, WriteConcern, WriteConcernSchema, type WriteConcernValue, type WriteOptions$1 as WriteOptions, type WriteResult, combineHashes, compareHLCTimestamps, compareTimestamps, deepMerge, deserialize, disableNativeHash, evaluatePredicate, getHighestWriteConcernLevel, hashORMapEntry, hashORMapRecord, hashString, isUsingNativeHash, isWriteConcernAchieved, resetNativeHash, serialize, timestampToString, validateProcessorCode, validateResolverCode };