@topgunbuild/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,725 @@
+import { z } from 'zod';
+
+interface Timestamp {
+    millis: number;
+    counter: number;
+    nodeId: string;
+}
+declare class HLC {
+    private lastMillis;
+    private lastCounter;
+    private readonly nodeId;
+    private static readonly MAX_DRIFT;
+    constructor(nodeId: string);
+    get getNodeId(): string;
+    /**
+     * Generates a new unique timestamp for a local event.
+     * Ensures monotonicity: always greater than any previously generated or received timestamp.
+     */
+    now(): Timestamp;
+    /**
+     * Updates the local clock based on a received remote timestamp.
+     * Must be called whenever a message/event is received from another node.
+     */
+    update(remote: Timestamp): void;
+    /**
+     * Compares two timestamps.
+     * Returns -1 if a < b, 1 if a > b, 0 if equal.
+     */
+    static compare(a: Timestamp, b: Timestamp): number;
+    /**
+     * Serializes timestamp to a string representation (e.g., for storage/network).
+     * Format: "<millis>:<counter>:<nodeId>"
+     */
+    static toString(ts: Timestamp): string;
+    /**
+     * Parses a string representation back to a Timestamp object.
+     */
+    static parse(str: string): Timestamp;
+}
+
+interface MerkleNode {
+    hash: number;
+    children?: {
+        [key: string]: MerkleNode;
+    };
+    entries?: Map<string, number>;
+}
+/**
+ * A specific implementation of Merkle Tree for syncing LWW-Maps.
+ * It uses a Prefix Trie structure based on the hash of the Record Key.
+ *
+ * Structure:
+ * - Level 0: Root
+ * - Level 1..N: Buckets based on hex digits of Key Hash.
+ *
+ * This allows us to quickly identify which "bucket" of keys is out of sync.
+ */
+declare class MerkleTree {
+    private root;
+    private readonly depth;
+    constructor(records?: Map<string, LWWRecord<any>>, depth?: number);
+    /**
+     * Incrementally updates the Merkle Tree with a single record.
+     * @param key The key of the record
+     * @param record The record (value + timestamp)
+     */
+    update(key: string, record: LWWRecord<any>): void;
+    /**
+     * Removes a key from the Merkle Tree.
+     * Necessary for Garbage Collection of tombstones.
+     */
+    remove(key: string): void;
+    private removeNode;
+    private updateNode;
+    getRootHash(): number;
+    getNode(path: string): MerkleNode | undefined;
+    /**
+     * Returns the hashes of the children at the given path.
+     * Used by the client/server to compare buckets.
+     */
+    getBuckets(path: string): Record<string, number>;
+    /**
+     * For a leaf node (bucket), returns the actual keys it contains.
+     * Used to request specific keys when a bucket differs.
+     */
+    getKeysInBucket(path: string): string[];
+}
+
+/**
+ * A record in the LWW-Map.
+ * Can represent a value or a deletion (tombstone).
+ */
+interface LWWRecord<V> {
+    value: V | null;
+    timestamp: Timestamp;
+    ttlMs?: number;
+}
+/**
+ * Last-Write-Wins Map Implementation.
+ * This structure guarantees convergence by always keeping the entry with the highest timestamp.
+ */
+declare class LWWMap<K, V> {
+    private data;
+    private readonly hlc;
+    private listeners;
+    private merkleTree;
+    constructor(hlc: HLC);
+    onChange(callback: () => void): () => void;
+    private notify;
+    getMerkleTree(): MerkleTree;
+    get size(): number;
+    /**
+     * Sets a value for a key.
+     * Generates a new timestamp using the local HLC.
+     */
+    set(key: K, value: V, ttlMs?: number): LWWRecord<V>;
+    /**
+     * Retrieves the value for a key.
+     * Returns undefined if key doesn't exist, is a tombstone, or is expired.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Returns the full record (including timestamp).
+     * Useful for synchronization.
+     */
+    getRecord(key: K): LWWRecord<V> | undefined;
+    /**
+     * Removes a key (creates a tombstone).
+     */
+    remove(key: K): LWWRecord<V>;
+    /**
+     * Merges a record from a remote source.
+     * Returns true if the local state was updated.
+     */
+    merge(key: K, remoteRecord: LWWRecord<V>): boolean;
+    /**
+     * Garbage Collection: Prunes tombstones older than the specified timestamp.
+     * Only removes records that are tombstones (deleted) AND older than the threshold.
+     *
+     * @param olderThan The timestamp threshold. Tombstones older than this will be removed.
+     * @returns The number of tombstones removed.
+     */
+    prune(olderThan: Timestamp): K[];
+    /**
+     * Clears all data and tombstones.
+     * Resets the MerkleTree.
+     */
+    clear(): void;
+    /**
+     * Returns an iterator over all non-deleted entries.
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Returns all keys (including tombstones).
+     */
+    allKeys(): IterableIterator<K>;
+}
+
+/**
+ * A record in the OR-Map (Observed-Remove Map).
+ * Represents a single value instance with a unique tag.
+ */
+interface ORMapRecord<V> {
+    value: V;
+    timestamp: Timestamp;
+    tag: string;
+    ttlMs?: number;
+}
+/**
+ * OR-Map (Observed-Remove Map) Implementation.
+ *
+ * Acts as a Multimap where each Key holds a Set of Values.
+ * Supports concurrent additions to the same key without data loss.
+ *
+ * Logic:
+ * - Add(K, V): Generates a unique tag. Stores (V, tag) under K.
+ * - Remove(K, V): Finds all *currently observed* tags for V under K, and moves them to a Remove Set (Tombstones).
+ * - Merge: Union of items minus Union of tombstones.
+ */
+declare class ORMap<K, V> {
+    private items;
+    private tombstones;
+    private readonly hlc;
+    constructor(hlc: HLC);
+    private listeners;
+    onChange(callback: () => void): () => void;
+    private notify;
+    get size(): number;
+    get totalRecords(): number;
+    /**
+     * Adds a value to the set associated with the key.
+     * Generates a unique tag for this specific addition.
+     */
+    add(key: K, value: V, ttlMs?: number): ORMapRecord<V>;
+    /**
+     * Removes a specific value from the set associated with the key.
+     * Marks all *currently observed* instances of this value as removed (tombstones).
+     * Returns the list of tags that were removed (useful for sync).
+     */
+    remove(key: K, value: V): string[];
+    /**
+     * Clears all data and tombstones.
+     */
+    clear(): void;
+    /**
+     * Returns all active values for a key.
+     * Filters out expired records.
+     */
+    get(key: K): V[];
+    /**
+     * Returns all active records for a key.
+     * Useful for persistence and sync.
+     * Filters out expired records.
+     */
+    getRecords(key: K): ORMapRecord<V>[];
+    /**
+     * Returns all tombstone tags.
+     */
+    getTombstones(): string[];
+    /**
+     * Applies a record from a remote source (Sync).
+     */
+    apply(key: K, record: ORMapRecord<V>): void;
+    /**
+     * Applies a tombstone (deletion) from a remote source.
+     */
+    applyTombstone(tag: string): void;
+    /**
+     * Merges state from another ORMap.
+     * - Adds all new tombstones from 'other'.
+     * - Adds all new items from 'other' that are not in tombstones.
+     * - Updates HLC with observed timestamps.
+     */
+    merge(other: ORMap<K, V>): void;
+    /**
+     * Garbage Collection: Prunes tombstones older than the specified timestamp.
+     */
+    prune(olderThan: Timestamp): string[];
+}
+
+/**
+ * FNV-1a Hash implementation for strings.
+ * Fast, non-cryptographic, synchronous.
+ * Good enough for data synchronization checks.
+ */
+declare function hashString(str: string): number;
+/**
+ * Combines multiple hash numbers into one order-independent hash.
+ * Used for combining bucket hashes.
+ * XOR is simple and effective for order-independent combination,
+ * but for Merkle trees we usually want position dependence if it's a Trie,
+ * or order-independence if it's a Set.
+ * Here we simply sum or XOR.
+ */
+declare function combineHashes(hashes: number[]): number;
+
+/**
+ * Serializes a JavaScript object to MessagePack binary format.
+ * @param data The data to serialize.
+ * @returns A Uint8Array containing the serialized data.
+ */
+declare function serialize(data: unknown): Uint8Array;
+/**
+ * Deserializes MessagePack binary data to a JavaScript object.
+ * @param data The binary data to deserialize (Uint8Array or ArrayBuffer).
+ * @returns The deserialized object.
+ */
+declare function deserialize<T = unknown>(data: Uint8Array | ArrayBuffer): T;
+
+type PredicateOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'regex' | 'and' | 'or' | 'not';
+interface PredicateNode {
+    op: PredicateOp;
+    attribute?: string;
+    value?: any;
+    children?: PredicateNode[];
+}
+declare class Predicates {
+    static equal(attribute: string, value: any): PredicateNode;
+    static notEqual(attribute: string, value: any): PredicateNode;
+    static greaterThan(attribute: string, value: any): PredicateNode;
+    static greaterThanOrEqual(attribute: string, value: any): PredicateNode;
+    static lessThan(attribute: string, value: any): PredicateNode;
+    static lessThanOrEqual(attribute: string, value: any): PredicateNode;
+    static like(attribute: string, pattern: string): PredicateNode;
+    static regex(attribute: string, pattern: string): PredicateNode;
+    static between(attribute: string, from: any, to: any): PredicateNode;
+    static and(...predicates: PredicateNode[]): PredicateNode;
+    static or(...predicates: PredicateNode[]): PredicateNode;
+    static not(predicate: PredicateNode): PredicateNode;
+}
+declare function evaluatePredicate(predicate: PredicateNode, data: any): boolean;
+
+type PermissionType = 'READ' | 'PUT' | 'REMOVE' | 'ALL';
+interface PermissionPolicy {
+    role: string;
+    mapNamePattern: string;
+    actions: PermissionType[];
+    allowedFields?: string[];
+}
+interface Principal {
+    userId: string;
+    roles: string[];
+    [key: string]: any;
+}
+
+declare const TimestampSchema: z.ZodObject<{
+    millis: z.ZodNumber;
+    counter: z.ZodNumber;
+    nodeId: z.ZodString;
+}, z.core.$strip>;
+declare const LWWRecordSchema: z.ZodObject<{
+    value: z.ZodNullable<z.ZodAny>;
+    timestamp: z.ZodObject<{
+        millis: z.ZodNumber;
+        counter: z.ZodNumber;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ORMapRecordSchema: z.ZodObject<{
+    value: z.ZodAny;
+    timestamp: z.ZodObject<{
+        millis: z.ZodNumber;
+        counter: z.ZodNumber;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    tag: z.ZodString;
+    ttlMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const PredicateOpSchema: z.ZodEnum<{
+    eq: "eq";
+    neq: "neq";
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    like: "like";
+    regex: "regex";
+    and: "and";
+    or: "or";
+    not: "not";
+}>;
+declare const PredicateNodeSchema: z.ZodType<any>;
+declare const QuerySchema: z.ZodObject<{
+    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    predicate: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
+    sort: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ClientOpSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    mapName: z.ZodString;
+    key: z.ZodString;
+    opType: z.ZodOptional<z.ZodString>;
+    record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        value: z.ZodNullable<z.ZodAny>;
+        timestamp: z.ZodObject<{
+            millis: z.ZodNumber;
+            counter: z.ZodNumber;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+        ttlMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        value: z.ZodAny;
+        timestamp: z.ZodObject<{
+            millis: z.ZodNumber;
+            counter: z.ZodNumber;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+        tag: z.ZodString;
+        ttlMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const AuthMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"AUTH">;
+    token: z.ZodString;
+}, z.core.$strip>;
+declare const QuerySubMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"QUERY_SUB">;
+    payload: z.ZodObject<{
+        queryId: z.ZodString;
+        mapName: z.ZodString;
+        query: z.ZodObject<{
+            where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            predicate: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
+            sort: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const QueryUnsubMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"QUERY_UNSUB">;
+    payload: z.ZodObject<{
+        queryId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const ClientOpMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"CLIENT_OP">;
+    payload: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        mapName: z.ZodString;
+        key: z.ZodString;
+        opType: z.ZodOptional<z.ZodString>;
+        record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            value: z.ZodNullable<z.ZodAny>;
+            timestamp: z.ZodObject<{
+                millis: z.ZodNumber;
+                counter: z.ZodNumber;
+                nodeId: z.ZodString;
+            }, z.core.$strip>;
+            ttlMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            value: z.ZodAny;
+            timestamp: z.ZodObject<{
+                millis: z.ZodNumber;
+                counter: z.ZodNumber;
+                nodeId: z.ZodString;
+            }, z.core.$strip>;
+            tag: z.ZodString;
+            ttlMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const OpBatchMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"OP_BATCH">;
+    payload: z.ZodObject<{
+        ops: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            mapName: z.ZodString;
+            key: z.ZodString;
+            opType: z.ZodOptional<z.ZodString>;
+            record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                value: z.ZodNullable<z.ZodAny>;
+                timestamp: z.ZodObject<{
+                    millis: z.ZodNumber;
+                    counter: z.ZodNumber;
+                    nodeId: z.ZodString;
+                }, z.core.$strip>;
+                ttlMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                value: z.ZodAny;
+                timestamp: z.ZodObject<{
+                    millis: z.ZodNumber;
+                    counter: z.ZodNumber;
+                    nodeId: z.ZodString;
+                }, z.core.$strip>;
+                tag: z.ZodString;
+                ttlMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SyncInitMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_INIT">;
+    mapName: z.ZodString;
+    lastSyncTimestamp: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const SyncRespRootMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_RESP_ROOT">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        rootHash: z.ZodNumber;
+        timestamp: z.ZodObject<{
+            millis: z.ZodNumber;
+            counter: z.ZodNumber;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SyncRespBucketsMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_RESP_BUCKETS">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        path: z.ZodString;
+        buckets: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SyncRespLeafMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_RESP_LEAF">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        path: z.ZodString;
+        records: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            record: z.ZodObject<{
+                value: z.ZodNullable<z.ZodAny>;
+                timestamp: z.ZodObject<{
+                    millis: z.ZodNumber;
+                    counter: z.ZodNumber;
+                    nodeId: z.ZodString;
+                }, z.core.$strip>;
+                ttlMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const MerkleReqBucketMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"MERKLE_REQ_BUCKET">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const LockRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"LOCK_REQUEST">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        name: z.ZodString;
+        ttl: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const LockReleaseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"LOCK_RELEASE">;
+    payload: z.ZodObject<{
+        requestId: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        fencingToken: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const TopicSubSchema: z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_SUB">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const TopicUnsubSchema: z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_UNSUB">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const TopicPubSchema: z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_PUB">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+        data: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const TopicMessageEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_MESSAGE">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+        data: z.ZodAny;
+        publisherId: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"AUTH">;
+    token: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"QUERY_SUB">;
+    payload: z.ZodObject<{
+        queryId: z.ZodString;
+        mapName: z.ZodString;
+        query: z.ZodObject<{
+            where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            predicate: z.ZodOptional<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
+            sort: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            offset: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"QUERY_UNSUB">;
+    payload: z.ZodObject<{
+        queryId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"CLIENT_OP">;
+    payload: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        mapName: z.ZodString;
+        key: z.ZodString;
+        opType: z.ZodOptional<z.ZodString>;
+        record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            value: z.ZodNullable<z.ZodAny>;
+            timestamp: z.ZodObject<{
+                millis: z.ZodNumber;
+                counter: z.ZodNumber;
+                nodeId: z.ZodString;
+            }, z.core.$strip>;
+            ttlMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            value: z.ZodAny;
+            timestamp: z.ZodObject<{
+                millis: z.ZodNumber;
+                counter: z.ZodNumber;
+                nodeId: z.ZodString;
+            }, z.core.$strip>;
+            tag: z.ZodString;
+            ttlMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"OP_BATCH">;
+    payload: z.ZodObject<{
+        ops: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            mapName: z.ZodString;
+            key: z.ZodString;
+            opType: z.ZodOptional<z.ZodString>;
+            record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                value: z.ZodNullable<z.ZodAny>;
+                timestamp: z.ZodObject<{
+                    millis: z.ZodNumber;
+                    counter: z.ZodNumber;
+                    nodeId: z.ZodString;
+                }, z.core.$strip>;
+                ttlMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                value: z.ZodAny;
+                timestamp: z.ZodObject<{
+                    millis: z.ZodNumber;
+                    counter: z.ZodNumber;
+                    nodeId: z.ZodString;
+                }, z.core.$strip>;
+                tag: z.ZodString;
+                ttlMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_INIT">;
+    mapName: z.ZodString;
+    lastSyncTimestamp: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_RESP_ROOT">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        rootHash: z.ZodNumber;
+        timestamp: z.ZodObject<{
+            millis: z.ZodNumber;
+            counter: z.ZodNumber;
+            nodeId: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_RESP_BUCKETS">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        path: z.ZodString;
+        buckets: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"SYNC_RESP_LEAF">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        path: z.ZodString;
+        records: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            record: z.ZodObject<{
+                value: z.ZodNullable<z.ZodAny>;
+                timestamp: z.ZodObject<{
+                    millis: z.ZodNumber;
+                    counter: z.ZodNumber;
+                    nodeId: z.ZodString;
+                }, z.core.$strip>;
+                ttlMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"MERKLE_REQ_BUCKET">;
+    payload: z.ZodObject<{
+        mapName: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"LOCK_REQUEST">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        name: z.ZodString;
+        ttl: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"LOCK_RELEASE">;
+    payload: z.ZodObject<{
+        requestId: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        fencingToken: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_SUB">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_UNSUB">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"TOPIC_PUB">;
+    payload: z.ZodObject<{
+        topic: z.ZodString;
+        data: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+type Query = z.infer<typeof QuerySchema>;
+type ClientOp = z.infer<typeof ClientOpSchema>;
+type Message = z.infer<typeof MessageSchema>;
+
+export { AuthMessageSchema, type ClientOp, ClientOpMessageSchema, ClientOpSchema, HLC, LWWMap, type LWWRecord, LWWRecordSchema, LockReleaseSchema, LockRequestSchema, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, ORMap, type ORMapRecord, ORMapRecordSchema, OpBatchMessageSchema, type PermissionPolicy, type PermissionType, type PredicateNode, PredicateNodeSchema, type PredicateOp, PredicateOpSchema, Predicates, type Principal, type Query, QuerySchema, QuerySubMessageSchema, QueryUnsubMessageSchema, SyncInitMessageSchema, SyncRespBucketsMessageSchema, SyncRespLeafMessageSchema, SyncRespRootMessageSchema, type Timestamp, TimestampSchema, TopicMessageEventSchema, TopicPubSchema, TopicSubSchema, TopicUnsubSchema, combineHashes, deserialize, evaluatePredicate, hashString, serialize };