@topgunbuild/core 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -403,29 +403,59 @@ declare function hashORMapRecord<V>(record: ORMapRecord<V>): number;
 declare function compareTimestamps(a: Timestamp, b: Timestamp): number;
 
 /**
- * FNV-1a Hash implementation for strings.
- * Fast, non-cryptographic, synchronous.
- * Good enough for data synchronization checks.
+ * Hash utilities for TopGun
+ *
+ * Uses native xxHash64 when available (via @topgunbuild/native),
+ * falls back to FNV-1a for JS-only environments.
+ *
+ * Phase 3.05: Native Hash Integration
+ */
+/**
+ * Hash a string to a 32-bit unsigned integer.
+ *
+ * Uses native xxHash64 (truncated to 32 bits) when available,
+ * otherwise falls back to FNV-1a.
+ *
+ * @param str - String to hash
+ * @returns 32-bit unsigned integer hash
  */
 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.
+ * Used for combining bucket hashes in Merkle trees.
+ *
+ * Uses simple sum (with overflow handling) for order-independence.
+ *
+ * @param hashes - Array of hash values to combine
+ * @returns Combined hash as 32-bit unsigned integer
  */
 declare function combineHashes(hashes: number[]): number;
+/**
+ * Check if native hash module is being used.
+ * Useful for diagnostics and testing.
+ */
+declare function isUsingNativeHash(): boolean;
+/**
+ * Force use of FNV-1a hash (for testing/compatibility).
+ * After calling this, hashString will always use FNV-1a.
+ */
+declare function disableNativeHash(): void;
+/**
+ * Re-enable native hash loading (for testing).
+ * Resets the load state so native module can be loaded again.
+ */
+declare function resetNativeHash(): void;
 
 /**
  * Serializes a JavaScript object to MessagePack binary format.
+ * Uses msgpackr for 2-5x faster serialization compared to @msgpack/msgpack.
  * @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.
+ * Uses msgpackr for 2-5x faster deserialization compared to @msgpack/msgpack.
  * @param data The binary data to deserialize (Uint8Array or ArrayBuffer).
  * @returns The deserialized object.
  */
@@ -467,16 +497,27 @@ interface Principal {
     [key: string]: any;
 }
 
+/**
+ * Write Concern schema - defines when an operation is considered acknowledged.
+ */
+declare const WriteConcernSchema: z.ZodEnum<{
+    FIRE_AND_FORGET: "FIRE_AND_FORGET";
+    MEMORY: "MEMORY";
+    APPLIED: "APPLIED";
+    REPLICATED: "REPLICATED";
+    PERSISTED: "PERSISTED";
+}>;
+type WriteConcernValue = z.infer<typeof WriteConcernSchema>;
 declare const TimestampSchema: z.ZodObject<{
-    millis: z.ZodNumber;
-    counter: z.ZodNumber;
+    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>;
 declare const LWWRecordSchema: z.ZodObject<{
     value: z.ZodNullable<z.ZodAny>;
     timestamp: z.ZodObject<{
-        millis: z.ZodNumber;
-        counter: z.ZodNumber;
+        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>;
     ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -484,8 +525,8 @@ declare const LWWRecordSchema: z.ZodObject<{
 declare const ORMapRecordSchema: z.ZodObject<{
     value: z.ZodAny;
     timestamp: z.ZodObject<{
-        millis: z.ZodNumber;
-        counter: z.ZodNumber;
+        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>;
     tag: z.ZodString;
@@ -523,8 +564,8 @@ declare const ClientOpSchema: z.ZodObject<{
     record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         value: z.ZodNullable<z.ZodAny>;
         timestamp: z.ZodObject<{
-            millis: z.ZodNumber;
-            counter: z.ZodNumber;
+            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>;
         ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -532,14 +573,22 @@ declare const ClientOpSchema: z.ZodObject<{
     orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         value: z.ZodAny;
         timestamp: z.ZodObject<{
-            millis: z.ZodNumber;
-            counter: z.ZodNumber;
+            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>;
         tag: z.ZodString;
         ttlMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
     orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    writeConcern: z.ZodOptional<z.ZodEnum<{
+        FIRE_AND_FORGET: "FIRE_AND_FORGET";
+        MEMORY: "MEMORY";
+        APPLIED: "APPLIED";
+        REPLICATED: "REPLICATED";
+        PERSISTED: "PERSISTED";
+    }>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const AuthMessageSchema: z.ZodObject<{
     type: z.ZodLiteral<"AUTH">;
@@ -578,8 +627,8 @@ declare const ClientOpMessageSchema: z.ZodObject<{
         record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             value: z.ZodNullable<z.ZodAny>;
             timestamp: z.ZodObject<{
-                millis: z.ZodNumber;
-                counter: z.ZodNumber;
+                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>;
             ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -587,14 +636,22 @@ declare const ClientOpMessageSchema: z.ZodObject<{
         orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             value: z.ZodAny;
             timestamp: z.ZodObject<{
-                millis: z.ZodNumber;
-                counter: z.ZodNumber;
+                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>;
             tag: z.ZodString;
             ttlMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>>;
         orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        writeConcern: z.ZodOptional<z.ZodEnum<{
+            FIRE_AND_FORGET: "FIRE_AND_FORGET";
+            MEMORY: "MEMORY";
+            APPLIED: "APPLIED";
+            REPLICATED: "REPLICATED";
+            PERSISTED: "PERSISTED";
+        }>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 declare const OpBatchMessageSchema: z.ZodObject<{
@@ -608,8 +665,8 @@ declare const OpBatchMessageSchema: z.ZodObject<{
             record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 value: z.ZodNullable<z.ZodAny>;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -617,15 +674,31 @@ declare const OpBatchMessageSchema: z.ZodObject<{
             orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
                 ttlMs: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>>;
             orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            writeConcern: z.ZodOptional<z.ZodEnum<{
+                FIRE_AND_FORGET: "FIRE_AND_FORGET";
+                MEMORY: "MEMORY";
+                APPLIED: "APPLIED";
+                REPLICATED: "REPLICATED";
+                PERSISTED: "PERSISTED";
+            }>>;
+            timeout: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        writeConcern: z.ZodOptional<z.ZodEnum<{
+            FIRE_AND_FORGET: "FIRE_AND_FORGET";
+            MEMORY: "MEMORY";
+            APPLIED: "APPLIED";
+            REPLICATED: "REPLICATED";
+            PERSISTED: "PERSISTED";
+        }>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 declare const SyncInitMessageSchema: z.ZodObject<{
@@ -639,8 +712,8 @@ declare const SyncRespRootMessageSchema: z.ZodObject<{
         mapName: z.ZodString;
         rootHash: z.ZodNumber;
         timestamp: z.ZodObject<{
-            millis: z.ZodNumber;
-            counter: z.ZodNumber;
+            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>;
@@ -663,8 +736,8 @@ declare const SyncRespLeafMessageSchema: z.ZodObject<{
             record: z.ZodObject<{
                 value: z.ZodNullable<z.ZodAny>;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -732,6 +805,16 @@ declare const PongMessageSchema: z.ZodObject<{
     timestamp: z.ZodNumber;
     serverTime: z.ZodNumber;
 }, z.core.$strip>;
+/**
+ * BATCH: Server sends multiple messages batched together.
+ * Uses length-prefixed binary format for efficiency.
+ * Format: [4 bytes: count][4 bytes: len1][msg1][4 bytes: len2][msg2]...
+ */
+declare const BatchMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"BATCH">;
+    count: z.ZodNumber;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+}, z.core.$strip>;
 /**
  * ORMAP_SYNC_INIT: Client initiates ORMap sync
  * Sends root hash and bucket hashes to server
@@ -752,8 +835,8 @@ declare const ORMapSyncRespRootSchema: z.ZodObject<{
         mapName: z.ZodString;
         rootHash: z.ZodNumber;
         timestamp: z.ZodObject<{
-            millis: z.ZodNumber;
-            counter: z.ZodNumber;
+            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>;
@@ -792,8 +875,8 @@ declare const ORMapSyncRespLeafSchema: z.ZodObject<{
             records: z.ZodArray<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
@@ -825,8 +908,8 @@ declare const ORMapDiffResponseSchema: z.ZodObject<{
             records: z.ZodArray<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
@@ -848,8 +931,8 @@ declare const ORMapPushDiffSchema: z.ZodObject<{
             records: z.ZodArray<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
@@ -859,6 +942,70 @@ declare const ORMapPushDiffSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/**
+ * PARTITION_MAP_REQUEST: Client requests current partition map
+ */
+declare const PartitionMapRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"PARTITION_MAP_REQUEST">;
+    payload: z.ZodOptional<z.ZodObject<{
+        currentVersion: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Individual operation result within a batch ACK
+ */
+declare const OpResultSchema: z.ZodObject<{
+    opId: z.ZodString;
+    success: z.ZodBoolean;
+    achievedLevel: z.ZodEnum<{
+        FIRE_AND_FORGET: "FIRE_AND_FORGET";
+        MEMORY: "MEMORY";
+        APPLIED: "APPLIED";
+        REPLICATED: "REPLICATED";
+        PERSISTED: "PERSISTED";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * OP_ACK: Server acknowledges write operations
+ * Extended to support Write Concern levels
+ */
+declare const OpAckMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"OP_ACK">;
+    payload: z.ZodObject<{
+        lastId: z.ZodString;
+        achievedLevel: z.ZodOptional<z.ZodEnum<{
+            FIRE_AND_FORGET: "FIRE_AND_FORGET";
+            MEMORY: "MEMORY";
+            APPLIED: "APPLIED";
+            REPLICATED: "REPLICATED";
+            PERSISTED: "PERSISTED";
+        }>>;
+        results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            opId: z.ZodString;
+            success: z.ZodBoolean;
+            achievedLevel: z.ZodEnum<{
+                FIRE_AND_FORGET: "FIRE_AND_FORGET";
+                MEMORY: "MEMORY";
+                APPLIED: "APPLIED";
+                REPLICATED: "REPLICATED";
+                PERSISTED: "PERSISTED";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * OP_REJECTED: Server rejects a write operation
+ */
+declare const OpRejectedMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"OP_REJECTED">;
+    payload: z.ZodObject<{
+        opId: z.ZodString;
+        reason: z.ZodString;
+        code: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"AUTH">;
     token: z.ZodString;
@@ -893,8 +1040,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             value: z.ZodNullable<z.ZodAny>;
             timestamp: z.ZodObject<{
-                millis: z.ZodNumber;
-                counter: z.ZodNumber;
+                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>;
             ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -902,14 +1049,22 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             value: z.ZodAny;
             timestamp: z.ZodObject<{
-                millis: z.ZodNumber;
-                counter: z.ZodNumber;
+                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>;
             tag: z.ZodString;
             ttlMs: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>>;
         orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        writeConcern: z.ZodOptional<z.ZodEnum<{
+            FIRE_AND_FORGET: "FIRE_AND_FORGET";
+            MEMORY: "MEMORY";
+            APPLIED: "APPLIED";
+            REPLICATED: "REPLICATED";
+            PERSISTED: "PERSISTED";
+        }>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"OP_BATCH">;
@@ -922,8 +1077,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             record: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 value: z.ZodNullable<z.ZodAny>;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -931,15 +1086,31 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             orRecord: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
                 ttlMs: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>>;
             orTag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            writeConcern: z.ZodOptional<z.ZodEnum<{
+                FIRE_AND_FORGET: "FIRE_AND_FORGET";
+                MEMORY: "MEMORY";
+                APPLIED: "APPLIED";
+                REPLICATED: "REPLICATED";
+                PERSISTED: "PERSISTED";
+            }>>;
+            timeout: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        writeConcern: z.ZodOptional<z.ZodEnum<{
+            FIRE_AND_FORGET: "FIRE_AND_FORGET";
+            MEMORY: "MEMORY";
+            APPLIED: "APPLIED";
+            REPLICATED: "REPLICATED";
+            PERSISTED: "PERSISTED";
+        }>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"SYNC_INIT">;
@@ -951,8 +1122,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         mapName: z.ZodString;
         rootHash: z.ZodNumber;
         timestamp: z.ZodObject<{
-            millis: z.ZodNumber;
-            counter: z.ZodNumber;
+            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>;
@@ -973,8 +1144,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             record: z.ZodObject<{
                 value: z.ZodNullable<z.ZodAny>;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 ttlMs: z.ZodOptional<z.ZodNumber>;
@@ -1036,8 +1207,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         mapName: z.ZodString;
         rootHash: z.ZodNumber;
         timestamp: z.ZodObject<{
-            millis: z.ZodNumber;
-            counter: z.ZodNumber;
+            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>;
@@ -1064,8 +1235,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             records: z.ZodArray<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
@@ -1089,8 +1260,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             records: z.ZodArray<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
@@ -1108,8 +1279,8 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             records: z.ZodArray<z.ZodObject<{
                 value: z.ZodAny;
                 timestamp: z.ZodObject<{
-                    millis: z.ZodNumber;
-                    counter: z.ZodNumber;
+                    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>;
                 tag: z.ZodString;
@@ -1118,11 +1289,488 @@ declare const MessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             tombstones: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"PARTITION_MAP_REQUEST">;
+    payload: z.ZodOptional<z.ZodObject<{
+        currentVersion: z.ZodOptional<z.ZodNumber>;
+    }, 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>;
 type PingMessage = z.infer<typeof PingMessageSchema>;
 type PongMessage = z.infer<typeof PongMessageSchema>;
+type BatchMessage = z.infer<typeof BatchMessageSchema>;
+type OpAckMessage = z.infer<typeof OpAckMessageSchema>;
+type OpRejectedMessage = z.infer<typeof OpRejectedMessageSchema>;
+type OpResult = z.infer<typeof OpResultSchema>;
+
+/**
+ * Write Concern - Configurable Acknowledgment Levels
+ *
+ * Write Concern defines when a write operation is considered successful.
+ * Similar to MongoDB's writeConcern, Kafka's acks, and Cassandra's consistency levels.
+ */
+/**
+ * Write Concern levels - determines when an operation is acknowledged.
+ *
+ * Levels are ordered by durability guarantee (lowest to highest):
+ * FIRE_AND_FORGET < MEMORY < APPLIED < REPLICATED < PERSISTED
+ */
+declare enum WriteConcern {
+    /**
+     * FIRE_AND_FORGET (acks=0)
+     * - ACK sent immediately after server receives the message
+     * - Operation may be lost if server crashes before processing
+     * - Maximum throughput, minimum latency
+     * - Use case: metrics, logs, non-critical data
+     */
+    FIRE_AND_FORGET = "FIRE_AND_FORGET",
+    /**
+     * MEMORY (acks=1, default) - current Early ACK behavior
+     * - ACK sent after validation and queuing for processing
+     * - Operation is in memory but not yet applied to CRDT
+     * - Use case: most operations, real-time updates
+     */
+    MEMORY = "MEMORY",
+    /**
+     * APPLIED
+     * - ACK sent after operation is applied to CRDT in memory
+     * - Data is readable on this node immediately after ACK
+     * - Use case: operations requiring immediate consistency on the node
+     */
+    APPLIED = "APPLIED",
+    /**
+     * REPLICATED
+     * - ACK sent after operation is broadcast to cluster (CLUSTER_EVENT sent)
+     * - Data survives primary node failure
+     * - Use case: important data requiring cluster durability
+     */
+    REPLICATED = "REPLICATED",
+    /**
+     * PERSISTED
+     * - ACK sent after operation is written to storage on primary node
+     * - Data survives node restart
+     * - Use case: critical data (financial transactions, audit logs)
+     */
+    PERSISTED = "PERSISTED"
+}
+/**
+ * Default timeout for Write Concern acknowledgments (ms)
+ */
+declare const DEFAULT_WRITE_CONCERN_TIMEOUT = 5000;
+/**
+ * Write options for PUT/REMOVE operations
+ */
+interface WriteOptions$1 {
+    /**
+     * Write acknowledgment level.
+     * @default WriteConcern.MEMORY
+     */
+    writeConcern?: WriteConcern;
+    /**
+     * Timeout for waiting for acknowledgment (ms).
+     * Applies to APPLIED, REPLICATED, PERSISTED levels.
+     * @default 5000
+     */
+    timeout?: number;
+}
+/**
+ * Result of a write operation
+ */
+interface WriteResult {
+    /** Whether the operation achieved the requested Write Concern level */
+    success: boolean;
+    /** Operation ID */
+    opId: string;
+    /** The Write Concern level actually achieved */
+    achievedLevel: WriteConcern;
+    /** Time taken to achieve the level (ms) */
+    latencyMs: number;
+    /** Error message if success=false */
+    error?: string;
+}
+/**
+ * Internal structure for tracking pending write acknowledgments
+ */
+interface PendingWrite {
+    /** Operation ID */
+    opId: string;
+    /** Target Write Concern level */
+    writeConcern: WriteConcern;
+    /** Timestamp when operation was registered */
+    timestamp: number;
+    /** Timeout duration (ms) */
+    timeout: number;
+    /** Promise resolve callback */
+    resolve: (result: WriteResult) => void;
+    /** Promise reject callback */
+    reject: (error: Error) => void;
+    /** Timeout handle for cleanup */
+    timeoutHandle?: ReturnType<typeof setTimeout>;
+    /** Set of levels that have been achieved */
+    achievedLevels: Set<WriteConcern>;
+}
+/**
+ * Ordered list of Write Concern levels (lowest to highest)
+ */
+declare const WRITE_CONCERN_ORDER: readonly WriteConcern[];
+/**
+ * Check if a target Write Concern level is achieved based on achieved levels.
+ *
+ * @param achieved - Set of achieved Write Concern levels
+ * @param target - Target Write Concern level to check
+ * @returns true if target level (or higher) is achieved
+ */
+declare function isWriteConcernAchieved(achieved: Set<WriteConcern>, target: WriteConcern): boolean;
+/**
+ * Get the highest achieved Write Concern level from a set of achieved levels.
+ *
+ * @param achieved - Set of achieved Write Concern levels
+ * @returns The highest achieved level
+ */
+declare function getHighestWriteConcernLevel(achieved: Set<WriteConcern>): WriteConcern;
+
+/**
+ * Cluster types for Phase 4: Clustering Improvements
+ *
+ * These types are shared between client and server packages
+ * for partition-aware routing and cluster communication.
+ */
+type NodeStatus = 'ACTIVE' | 'JOINING' | 'LEAVING' | 'SUSPECTED' | 'FAILED';
+interface NodeInfo {
+    nodeId: string;
+    endpoints: {
+        websocket: string;
+        http?: string;
+    };
+    status: NodeStatus;
+}
+interface PartitionInfo {
+    partitionId: number;
+    ownerNodeId: string;
+    backupNodeIds: string[];
+}
+interface PartitionMap {
+    version: number;
+    partitionCount: number;
+    nodes: NodeInfo[];
+    partitions: PartitionInfo[];
+    generatedAt: number;
+}
+interface PartitionMapMessage {
+    type: 'PARTITION_MAP';
+    payload: PartitionMap;
+}
+interface PartitionMapRequestMessage {
+    type: 'PARTITION_MAP_REQUEST';
+    payload?: {
+        currentVersion?: number;
+    };
+}
+interface PartitionChange {
+    partitionId: number;
+    previousOwner: string;
+    newOwner: string;
+    reason: 'REBALANCE' | 'FAILOVER' | 'JOIN' | 'LEAVE';
+}
+interface PartitionMapDeltaMessage {
+    type: 'PARTITION_MAP_DELTA';
+    payload: {
+        version: number;
+        previousVersion: number;
+        changes: PartitionChange[];
+        timestamp: number;
+    };
+}
+interface NotOwnerError {
+    code: 'NOT_OWNER';
+    message: string;
+    hint: {
+        partitionId: number;
+        currentOwner: string;
+        mapVersion: number;
+    };
+}
+interface StaleMapError {
+    code: 'STALE_MAP';
+    message: string;
+    hint: {
+        clientVersion: number;
+        serverVersion: number;
+    };
+}
+type RoutingError = NotOwnerError | StaleMapError;
+interface ConnectionPoolConfig {
+    /** Maximum connections per node (default: 1) */
+    maxConnectionsPerNode: number;
+    /** Connection timeout in ms (default: 5000) */
+    connectionTimeoutMs: number;
+    /** Health check interval in ms (default: 10000) */
+    healthCheckIntervalMs: number;
+    /** Reconnect delay base in ms (default: 1000) */
+    reconnectDelayMs: number;
+    /** Maximum reconnect delay in ms (default: 30000) */
+    maxReconnectDelayMs: number;
+    /** Maximum reconnect attempts before marking unhealthy (default: 5) */
+    maxReconnectAttempts: number;
+}
+declare const DEFAULT_CONNECTION_POOL_CONFIG: ConnectionPoolConfig;
+interface PartitionRouterConfig {
+    /** Fallback mode when routing fails: 'forward' uses primary, 'error' throws */
+    fallbackMode: 'forward' | 'error';
+    /** How often to refresh stale partition map in ms (default: 30000) */
+    mapRefreshIntervalMs: number;
+    /** Max staleness before forcing refresh in ms (default: 60000) */
+    maxMapStalenessMs: number;
+}
+declare const DEFAULT_PARTITION_ROUTER_CONFIG: PartitionRouterConfig;
+/**
+ * Circuit breaker configuration.
+ */
+interface CircuitBreakerConfig {
+    /** Number of failures before opening circuit (default: 5) */
+    failureThreshold: number;
+    /** Time in ms before attempting to close circuit (default: 30000) */
+    resetTimeoutMs: number;
+}
+declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: CircuitBreakerConfig;
+interface ClusterClientConfig {
+    /** Enable cluster mode */
+    enabled: boolean;
+    /** Initial seed nodes to connect to */
+    seedNodes: string[];
+    /** Routing mode: 'direct' routes to owner, 'forward' uses server forwarding */
+    routingMode: 'direct' | 'forward';
+    /** Connection pool configuration */
+    connectionPool?: Partial<ConnectionPoolConfig>;
+    /** Partition router configuration */
+    routing?: Partial<PartitionRouterConfig>;
+    /** Circuit breaker configuration */
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
+}
+type ConnectionState = 'DISCONNECTED' | 'CONNECTING' | 'CONNECTED' | 'AUTHENTICATED' | 'RECONNECTING' | 'FAILED';
+interface NodeHealth {
+    nodeId: string;
+    state: ConnectionState;
+    lastSeen: number;
+    latencyMs: number;
+    reconnectAttempts: number;
+}
+interface ClusterEvents {
+    'node:connected': {
+        nodeId: string;
+    };
+    'node:disconnected': {
+        nodeId: string;
+        reason: string;
+    };
+    'node:healthy': {
+        nodeId: string;
+    };
+    'node:unhealthy': {
+        nodeId: string;
+        reason: string;
+    };
+    'partitionMap:updated': {
+        version: number;
+        changesCount: number;
+    };
+    'partitionMap:stale': {
+        currentVersion: number;
+        lastRefresh: number;
+    };
+    'routing:miss': {
+        key: string;
+        expectedOwner: string;
+        actualOwner: string;
+    };
+}
+declare enum PartitionState {
+    STABLE = "STABLE",// Normal operation
+    MIGRATING = "MIGRATING",// Data being transferred
+    SYNC = "SYNC",// Verifying consistency
+    FAILED = "FAILED"
+}
+interface PartitionMigration {
+    partitionId: number;
+    state: PartitionState;
+    sourceNode: string;
+    targetNode: string;
+    startTime: number;
+    bytesTransferred: number;
+    totalBytes: number;
+    retryCount: number;
+}
+interface MigrationConfig {
+    /** Partitions per batch (default: 10) */
+    batchSize: number;
+    /** Delay between batches in ms (default: 5000) */
+    batchIntervalMs: number;
+    /** Bytes per chunk (default: 64KB) */
+    transferChunkSize: number;
+    /** Retries per partition (default: 3) */
+    maxRetries: number;
+    /** Sync phase timeout in ms (default: 30000) */
+    syncTimeoutMs: number;
+    /** Concurrent transfers (default: 4) */
+    parallelTransfers: number;
+}
+declare const DEFAULT_MIGRATION_CONFIG: MigrationConfig;
+interface MigrationStatus {
+    inProgress: boolean;
+    active: PartitionMigration[];
+    queued: number;
+    completed: number;
+    failed: number;
+    estimatedTimeRemainingMs: number;
+}
+interface MigrationMetrics {
+    migrationsStarted: number;
+    migrationsCompleted: number;
+    migrationsFailed: number;
+    chunksTransferred: number;
+    bytesTransferred: number;
+    activeMigrations: number;
+    queuedMigrations: number;
+}
+interface MigrationStartMessage {
+    type: 'MIGRATION_START';
+    payload: {
+        partitionId: number;
+        sourceNode: string;
+        estimatedSize: number;
+    };
+}
+interface MigrationChunkMessage {
+    type: 'MIGRATION_CHUNK';
+    payload: {
+        partitionId: number;
+        chunkIndex: number;
+        totalChunks: number;
+        data: Uint8Array;
+        checksum: string;
+    };
+}
+interface MigrationChunkAckMessage {
+    type: 'MIGRATION_CHUNK_ACK';
+    payload: {
+        partitionId: number;
+        chunkIndex: number;
+        success: boolean;
+    };
+}
+interface MigrationCompleteMessage {
+    type: 'MIGRATION_COMPLETE';
+    payload: {
+        partitionId: number;
+        totalRecords: number;
+        checksum: string;
+    };
+}
+interface MigrationVerifyMessage {
+    type: 'MIGRATION_VERIFY';
+    payload: {
+        partitionId: number;
+        success: boolean;
+        checksumMatch: boolean;
+    };
+}
+type MigrationMessage = MigrationStartMessage | MigrationChunkMessage | MigrationChunkAckMessage | MigrationCompleteMessage | MigrationVerifyMessage;
+declare enum ConsistencyLevel {
+    /** Wait for all replicas (owner + all backups) */
+    STRONG = "STRONG",
+    /** Wait for majority (owner + N/2 backups) */
+    QUORUM = "QUORUM",
+    /** Acknowledge after owner write only, background replication */
+    EVENTUAL = "EVENTUAL"
+}
+interface WriteOptions {
+    consistency?: ConsistencyLevel;
+    /** Replication timeout in ms */
+    timeout?: number;
+}
+interface ReadOptions {
+    consistency?: ConsistencyLevel;
+    /** Read from backup if owner unavailable */
+    allowStale?: boolean;
+    /** Max acceptable lag in ms */
+    maxStaleness?: number;
+}
+interface ReplicationConfig {
+    defaultConsistency: ConsistencyLevel;
+    /** Max queued operations (default: 10000) */
+    queueSizeLimit: number;
+    /** Operations per batch (default: 100) */
+    batchSize: number;
+    /** Batch flush interval in ms (default: 50) */
+    batchIntervalMs: number;
+    /** Ack timeout in ms (default: 5000) */
+    ackTimeoutMs: number;
+    /** Retries before marking node unhealthy (default: 3) */
+    maxRetries: number;
+}
+declare const DEFAULT_REPLICATION_CONFIG: ReplicationConfig;
+interface ReplicationTask {
+    opId: string;
+    operation: unknown;
+    consistency: ConsistencyLevel;
+    timestamp: number;
+    retryCount: number;
+}
+interface ReplicationLag {
+    /** Current lag in ms */
+    current: number;
+    /** Average lag */
+    avg: number;
+    /** Maximum observed lag */
+    max: number;
+    /** 99th percentile lag */
+    percentile99: number;
+}
+interface ReplicationHealth {
+    healthy: boolean;
+    unhealthyNodes: string[];
+    laggyNodes: string[];
+    avgLagMs: number;
+}
+interface ReplicationResult {
+    success: boolean;
+    ackedBy: string[];
+}
+interface ReplicationMessage {
+    type: 'REPLICATION';
+    payload: {
+        opId: string;
+        operation: unknown;
+        consistency: ConsistencyLevel;
+    };
+}
+interface ReplicationBatchMessage {
+    type: 'REPLICATION_BATCH';
+    payload: {
+        operations: unknown[];
+        opIds: string[];
+    };
+}
+interface ReplicationAckMessage {
+    type: 'REPLICATION_ACK';
+    payload: {
+        opId: string;
+        success: boolean;
+        timestamp: number;
+    };
+}
+interface ReplicationBatchAckMessage {
+    type: 'REPLICATION_BATCH_ACK';
+    payload: {
+        opIds: string[];
+        success: boolean;
+        timestamp: number;
+    };
+}
+type ReplicationProtocolMessage = ReplicationMessage | ReplicationBatchMessage | ReplicationAckMessage | ReplicationBatchAckMessage;
+declare const PARTITION_COUNT = 271;
+declare const DEFAULT_BACKUP_COUNT = 1;
 
-export { AuthMessageSchema, type ClientOp, ClientOpMessageSchema, ClientOpSchema, HLC, LWWMap, type LWWRecord, LWWRecordSchema, LockReleaseSchema, LockRequestSchema, type MergeKeyResult, MerkleReqBucketMessageSchema, MerkleTree, type Message, MessageSchema, ORMap, ORMapDiffRequestSchema, ORMapDiffResponseSchema, type ORMapMerkleNode, ORMapMerkleReqBucketSchema, ORMapMerkleTree, ORMapPushDiffSchema, type ORMapRecord, ORMapRecordSchema, type ORMapSnapshot, ORMapSyncInitSchema, ORMapSyncRespBucketsSchema, ORMapSyncRespLeafSchema, ORMapSyncRespRootSchema, OpBatchMessageSchema, type PermissionPolicy, type PermissionType, type PingMessage, PingMessageSchema, type PongMessage, PongMessageSchema, 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, compareTimestamps, deserialize, evaluatePredicate, hashORMapEntry, hashORMapRecord, hashString, serialize, timestampToString };
+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 };