@topgunbuild/server 0.6.0 → 0.7.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _topgunbuild_core from '@topgunbuild/core';
-import { Timestamp, LWWRecord, ORMapRecord, Principal, EventJournalImpl, EventJournalConfig, JournalEvent, PermissionPolicy, ConsistencyLevel, ReplicationConfig, LWWMap, ORMap, PermissionType, MigrationConfig, MigrationStatus, MigrationMetrics, PartitionMap, PartitionInfo, PartitionChange, ReplicationLag, ReplicationHealth, ReplicationResult, EntryProcessorDef, EntryProcessorResult, HLC, MergeRejection, ConflictResolverDef, MergeContext, MergeResult, IndexedLWWMap, IndexedORMap } from '@topgunbuild/core';
+import { Timestamp, LWWRecord, ORMapRecord, Principal, EventJournalImpl, EventJournalConfig, JournalEvent, PermissionPolicy, ConsistencyLevel, ReplicationConfig, LWWMap, ORMap, PermissionType, MigrationConfig, MigrationStatus, MigrationMetrics, PartitionMap, PartitionInfo, PartitionChange, ReplicationLag, ReplicationHealth, ReplicationResult, ClusterReadOptions, MerkleTree, EntryProcessorDef, EntryProcessorResult, HLC, MergeRejection, ConflictResolverDef, MergeContext, MergeResult, IndexedLWWMap, IndexedORMap } from '@topgunbuild/core';
 import { WebSocket } from 'ws';
 import { Pool, PoolConfig } from 'pg';
 import pino from 'pino';
@@ -1902,6 +1902,10 @@ declare class ServerCoordinator {
     private conflictResolverHandler;
     private eventJournalService?;
     private journalSubscriptions;
+    private partitionReassigner?;
+    private readReplicaHandler?;
+    private merkleTreeManager?;
+    private repairScheduler?;
     private readonly _nodeId;
     private _actualPort;
     private _actualClusterPort;
@@ -1943,6 +1947,23 @@ declare class ServerCoordinator {
     getTaskletSchedulerStats(): TaskletSchedulerStats;
     /** Get tasklet scheduler for scheduling long-running operations */
     getTaskletScheduler(): TaskletScheduler;
+    /**
+     * Phase 10.02: Graceful cluster departure
+     *
+     * Notifies the cluster that this node is leaving and allows time for:
+     * 1. Pending replication to complete
+     * 2. Other nodes to detect departure
+     * 3. Partition reassignment to begin
+     */
+    private gracefulClusterDeparture;
+    /**
+     * Get list of partition IDs owned by this node
+     */
+    private getOwnedPartitions;
+    /**
+     * Wait for replication pipeline to flush pending operations
+     */
+    private waitForReplicationFlush;
     shutdown(): Promise<void>;
     private handleConnection;
     private handleMessage;
@@ -2052,6 +2073,16 @@ declare class ServerCoordinator {
      * Use this for queries to avoid returning empty results during initial load.
      */
     getMapAsync(name: string, typeHint?: 'LWW' | 'OR'): Promise<LWWMap<string, any> | ORMap<string, any>>;
+    /**
+     * Phase 10.04: Get local record for anti-entropy repair
+     * Returns the LWWRecord for a key, used by RepairScheduler
+     */
+    private getLocalRecord;
+    /**
+     * Phase 10.04: Apply repaired record from anti-entropy repair
+     * Used by RepairScheduler to apply resolved conflicts
+     */
+    private applyRepairRecord;
     private loadMapFromStorage;
     private startGarbageCollection;
     /**
@@ -2347,6 +2378,31 @@ interface FailureDetectorConfig {
     /** Initial heartbeat interval estimate (ms). Default: 1000 */
     initialHeartbeatIntervalMs: number;
 }
+declare const DEFAULT_FAILURE_DETECTOR_CONFIG: FailureDetectorConfig;
+interface NodeState {
+    /** Last heartbeat timestamp */
+    lastHeartbeat: number;
+    /** Heartbeat interval history for phi calculation */
+    intervalHistory: number[];
+    /** Whether node is currently suspected */
+    isSuspected: boolean;
+    /** Timestamp when suspicion started */
+    suspicionStartTime?: number;
+    /** Whether failure has been confirmed */
+    isConfirmedFailed: boolean;
+}
+interface FailureDetectorEvents {
+    nodeSuspected: {
+        nodeId: string;
+        phi: number;
+    };
+    nodeRecovered: {
+        nodeId: string;
+    };
+    nodeConfirmedFailed: {
+        nodeId: string;
+    };
+}
 declare class FailureDetector extends EventEmitter {
     private config;
     private nodeStates;
@@ -2460,7 +2516,7 @@ interface ClusterMember {
     isSelf: boolean;
 }
 interface ClusterMessage {
-    type: 'HELLO' | 'OP_FORWARD' | 'PARTITION_UPDATE' | 'HEARTBEAT' | 'CLUSTER_EVENT' | 'CLUSTER_QUERY_EXEC' | 'CLUSTER_QUERY_RESP' | 'CLUSTER_GC_REPORT' | 'CLUSTER_GC_COMMIT' | 'CLUSTER_LOCK_REQ' | 'CLUSTER_LOCK_RELEASE' | 'CLUSTER_LOCK_GRANTED' | 'CLUSTER_LOCK_RELEASED' | 'CLUSTER_CLIENT_DISCONNECTED' | 'CLUSTER_TOPIC_PUB';
+    type: 'HELLO' | 'MEMBER_LIST' | 'OP_FORWARD' | 'PARTITION_UPDATE' | 'HEARTBEAT' | 'CLUSTER_EVENT' | 'CLUSTER_QUERY_EXEC' | 'CLUSTER_QUERY_RESP' | 'CLUSTER_GC_REPORT' | 'CLUSTER_GC_COMMIT' | 'CLUSTER_LOCK_REQ' | 'CLUSTER_LOCK_RELEASE' | 'CLUSTER_LOCK_GRANTED' | 'CLUSTER_LOCK_RELEASED' | 'CLUSTER_CLIENT_DISCONNECTED' | 'CLUSTER_TOPIC_PUB' | 'CLUSTER_MERKLE_ROOT_REQ' | 'CLUSTER_MERKLE_ROOT_RESP' | 'CLUSTER_MERKLE_BUCKETS_REQ' | 'CLUSTER_MERKLE_BUCKETS_RESP' | 'CLUSTER_MERKLE_KEYS_REQ' | 'CLUSTER_MERKLE_KEYS_RESP' | 'CLUSTER_REPAIR_DATA_REQ' | 'CLUSTER_REPAIR_DATA_RESP';
     senderId: string;
     payload: any;
 }
@@ -2501,6 +2557,21 @@ declare class ClusterManager extends EventEmitter {
      * Handle incoming heartbeat from a peer.
      */
     private handleHeartbeat;
+    /**
+     * Send current member list to a specific node (gossip protocol).
+     * Called when a new node joins to propagate cluster topology.
+     */
+    private sendMemberList;
+    /**
+     * Broadcast member list to all connected nodes.
+     * Called when cluster membership changes.
+     */
+    private broadcastMemberList;
+    /**
+     * Handle incoming member list from a peer (gossip protocol).
+     * Attempts to connect to unknown members.
+     */
+    private handleMemberList;
     /**
      * Handle confirmed node failure.
      */
@@ -3187,6 +3258,505 @@ declare class ClusterCoordinator extends EventEmitter {
     private setupEventHandlers;
 }
 
+/**
+ * PartitionReassigner - Automatic Partition Failover
+ *
+ * Handles automatic reassignment of partitions when nodes fail:
+ * - Promotes backup nodes to owners
+ * - Assigns new backups from remaining cluster
+ * - Coordinates with MigrationManager for data transfer
+ * - Broadcasts partition table updates
+ *
+ * This is Phase 10.02 of the TopGun cluster enhancements.
+ */
+
+interface PartitionReassignerConfig {
+    /** Delay before reassigning partitions after failure detection (ms). Default: 1000 */
+    reassignmentDelayMs: number;
+    /** Maximum concurrent partition transfers. Default: 10 */
+    maxConcurrentTransfers: number;
+    /** Enable automatic backup promotion. Default: true */
+    autoPromoteBackups: boolean;
+    /** Enable automatic new backup assignment. Default: true */
+    autoAssignNewBackups: boolean;
+}
+declare const DEFAULT_REASSIGNER_CONFIG: PartitionReassignerConfig;
+interface ReassignmentEvent {
+    type: 'backup-promoted' | 'new-backup-assigned' | 'reassignment-complete';
+    partitionId: number;
+    previousOwner?: string;
+    newOwner?: string;
+    backups?: string[];
+    failedNodeId?: string;
+}
+interface FailoverStatus {
+    inProgress: boolean;
+    failedNodeId?: string;
+    partitionsReassigned: number;
+    partitionsPending: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+declare class PartitionReassigner extends EventEmitter {
+    private config;
+    private clusterManager;
+    private partitionService;
+    private failoverInProgress;
+    private currentFailedNode?;
+    private reassignmentStartTime?;
+    private partitionsReassigned;
+    private pendingReassignments;
+    private reassignmentTimer?;
+    constructor(clusterManager: ClusterManager, partitionService: PartitionService, config?: Partial<PartitionReassignerConfig>);
+    private setupEventHandlers;
+    /**
+     * Handle a node failure - initiates failover process
+     */
+    private handleNodeFailure;
+    /**
+     * Handle a graceful node departure
+     */
+    private handleNodeDeparture;
+    /**
+     * Execute the failover process for a failed node
+     */
+    private executeFailover;
+    /**
+     * Find all partitions that need reassignment
+     */
+    private findOrphanedPartitions;
+    /**
+     * Reassign a single partition
+     */
+    private reassignPartition;
+    /**
+     * Select backup nodes for a partition
+     */
+    private selectBackups;
+    /**
+     * Complete the failover process
+     */
+    private completeFailover;
+    /**
+     * Get current failover status
+     */
+    getStatus(): FailoverStatus;
+    /**
+     * Check if failover is in progress
+     */
+    isFailoverInProgress(): boolean;
+    /**
+     * Force immediate reassignment (for testing/manual intervention)
+     */
+    forceReassignment(failedNodeId: string): void;
+    /**
+     * Stop any pending reassignment
+     */
+    stop(): void;
+}
+
+/**
+ * ReadReplicaHandler - Read Scaling via Replicas
+ *
+ * Phase 10.03: Enables reading from backup nodes to:
+ * - Scale read throughput linearly with replicas
+ * - Reduce latency by reading from nearest replica
+ * - Provide availability during owner unavailability
+ *
+ * Supports three consistency levels for reads:
+ * - STRONG: Read from partition owner (current behavior)
+ * - EVENTUAL: Read from any replica (owner or backup)
+ * - LOCAL: Read from local node if it's a replica
+ */
+
+interface ReadReplicaConfig {
+    /** Default consistency for reads. Default: STRONG */
+    defaultConsistency: ConsistencyLevel;
+    /** Maximum staleness for eventual reads in ms. Default: 5000 */
+    maxStalenessMs: number;
+    /** Prefer local replica over remote. Default: true */
+    preferLocalReplica: boolean;
+    /** Load balancing strategy for replica selection. Default: 'latency-based' */
+    loadBalancing: 'round-robin' | 'least-connections' | 'latency-based';
+}
+declare const DEFAULT_READ_REPLICA_CONFIG: ReadReplicaConfig;
+interface ReadResult<T> {
+    value: T | null;
+    version?: Timestamp;
+    source: string;
+    isOwner: boolean;
+    staleness?: number;
+}
+interface ReadRequest {
+    mapName: string;
+    key: string;
+    options?: ClusterReadOptions;
+}
+declare class ReadReplicaHandler extends EventEmitter {
+    private config;
+    private partitionService;
+    private clusterManager;
+    private lagTracker?;
+    private nodeId;
+    private roundRobinCounters;
+    constructor(partitionService: PartitionService, clusterManager: ClusterManager, nodeId: string, lagTracker?: LagTracker, config?: Partial<ReadReplicaConfig>);
+    /**
+     * Determine if a read request can be served locally
+     */
+    canServeLocally(request: ReadRequest): boolean;
+    /**
+     * Determine which node should handle the read
+     */
+    selectReadNode(request: ReadRequest): string | null;
+    /**
+     * Select replica using configured load balancing strategy
+     */
+    private selectByStrategy;
+    /**
+     * Round-robin selection
+     */
+    private selectRoundRobin;
+    /**
+     * Latency-based selection using lag tracker
+     */
+    private selectByLatency;
+    /**
+     * Get estimated staleness for a node in ms
+     */
+    private getNodeStaleness;
+    /**
+     * Check if a node is alive in the cluster
+     */
+    private isNodeAlive;
+    /**
+     * Select first alive backup from list
+     */
+    private selectAliveBackup;
+    /**
+     * Create read response metadata
+     */
+    createReadMetadata(key: string, options?: ClusterReadOptions): {
+        source: string;
+        isOwner: boolean;
+        consistency: ConsistencyLevel;
+    };
+    /**
+     * Check if local node should forward read to owner
+     */
+    shouldForwardRead(request: ReadRequest): boolean;
+    /**
+     * Get metrics for monitoring
+     */
+    getMetrics(): {
+        defaultConsistency: ConsistencyLevel;
+        preferLocalReplica: boolean;
+        loadBalancing: string;
+        roundRobinPartitions: number;
+    };
+}
+
+/**
+ * MerkleTreeManager - Per-Partition Merkle Tree Management
+ *
+ * Phase 10.04: Manages Merkle trees for each partition to enable:
+ * - Efficient delta sync between nodes
+ * - Anti-entropy repair detection
+ * - Incremental updates on writes
+ *
+ * Each partition maintains its own Merkle tree for independent
+ * consistency checking and repair.
+ */
+
+interface MerkleTreeManagerConfig {
+    /** Tree depth for Merkle trees. Default: 3 */
+    treeDepth: number;
+    /** Enable automatic tree updates on write. Default: true */
+    autoUpdate: boolean;
+    /** Lazy initialization of trees. Default: true */
+    lazyInit: boolean;
+}
+declare const DEFAULT_MERKLE_TREE_CONFIG: MerkleTreeManagerConfig;
+interface MerkleComparisonResult {
+    partitionId: number;
+    localRoot: number;
+    remoteRoot: number;
+    needsSync: boolean;
+    differingBuckets: string[];
+}
+interface PartitionMerkleInfo {
+    partitionId: number;
+    rootHash: number;
+    keyCount: number;
+    lastUpdated: number;
+}
+declare class MerkleTreeManager extends EventEmitter {
+    private config;
+    private trees;
+    private keyCounts;
+    private lastUpdated;
+    private nodeId;
+    constructor(nodeId: string, config?: Partial<MerkleTreeManagerConfig>);
+    /**
+     * Get or create a Merkle tree for a partition
+     */
+    getTree(partitionId: number): MerkleTree;
+    /**
+     * Build tree for a partition from existing data
+     */
+    buildTree(partitionId: number, records: Map<string, LWWRecord<any>>): void;
+    /**
+     * Incrementally update tree when a record changes
+     */
+    updateRecord(partitionId: number, key: string, record: LWWRecord<any>): void;
+    /**
+     * Remove a key from the tree (e.g., after GC)
+     */
+    removeRecord(partitionId: number, key: string): void;
+    /**
+     * Get the path prefix for a key in the Merkle tree
+     */
+    private getKeyPath;
+    /**
+     * Get root hash for a partition
+     */
+    getRootHash(partitionId: number): number;
+    /**
+     * Compare local tree with remote root hash
+     */
+    compareWithRemote(partitionId: number, remoteRoot: number): MerkleComparisonResult;
+    /**
+     * Find buckets that differ between local and remote tree
+     * Note: This is a simplified version - full implementation would
+     * need to exchange bucket hashes with the remote node
+     */
+    private findDifferingBuckets;
+    /**
+     * Recursively collect all leaf bucket paths
+     */
+    private collectLeafBuckets;
+    /**
+     * Get bucket hashes for a partition at a given path
+     */
+    getBuckets(partitionId: number, path: string): Record<string, number>;
+    /**
+     * Get keys in a specific bucket
+     */
+    getKeysInBucket(partitionId: number, path: string): string[];
+    /**
+     * Get all keys across all buckets for a partition
+     */
+    getAllKeys(partitionId: number): string[];
+    /**
+     * Recursively collect all keys from the tree
+     */
+    private collectAllKeys;
+    /**
+     * Get info about all managed partitions
+     */
+    getPartitionInfos(): PartitionMerkleInfo[];
+    /**
+     * Get info for a specific partition
+     */
+    getPartitionInfo(partitionId: number): PartitionMerkleInfo | null;
+    /**
+     * Clear tree for a partition (e.g., after migration)
+     */
+    clearPartition(partitionId: number): void;
+    /**
+     * Clear all trees
+     */
+    clearAll(): void;
+    /**
+     * Get metrics for monitoring
+     */
+    getMetrics(): {
+        totalPartitions: number;
+        totalKeys: number;
+        averageKeysPerPartition: number;
+    };
+    /**
+     * Serialize tree state for network transfer
+     */
+    serializeTree(partitionId: number): {
+        rootHash: number;
+        buckets: Record<string, Record<string, number>>;
+    } | null;
+    private collectBucketsAtDepth;
+}
+
+/**
+ * RepairScheduler - Anti-Entropy Repair System
+ *
+ * Phase 10.04: Proactively detects and repairs data inconsistencies:
+ * - Periodic scanning of partitions
+ * - Merkle tree-based difference detection
+ * - LWW conflict resolution
+ * - Throttled repair execution
+ *
+ * Based on Cassandra/Dynamo anti-entropy patterns.
+ */
+
+interface RepairConfig {
+    /** Enable anti-entropy repair. Default: true */
+    enabled: boolean;
+    /** Interval between full scans in ms. Default: 3600000 (1 hour) */
+    scanIntervalMs: number;
+    /** Keys per repair batch. Default: 1000 */
+    repairBatchSize: number;
+    /** Maximum concurrent partition repairs. Default: 2 */
+    maxConcurrentRepairs: number;
+    /** Delay between batches in ms. Default: 100 */
+    throttleMs: number;
+    /** Prioritize recently modified partitions. Default: true */
+    prioritizeRecent: boolean;
+    /** Timeout for network requests in ms. Default: 5000 */
+    requestTimeoutMs: number;
+}
+declare const DEFAULT_REPAIR_CONFIG: RepairConfig;
+interface RepairTask {
+    partitionId: number;
+    replicaNodeId: string;
+    priority: 'high' | 'normal' | 'low';
+    scheduledAt: number;
+}
+interface RepairResult {
+    partitionId: number;
+    replicaNodeId: string;
+    keysScanned: number;
+    keysRepaired: number;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+}
+interface RepairMetrics {
+    scansCompleted: number;
+    repairsExecuted: number;
+    keysRepaired: number;
+    errorsEncountered: number;
+    lastScanTime?: number;
+    averageRepairDurationMs: number;
+}
+type RecordGetter = (key: string) => LWWRecord<any> | undefined;
+type RecordSetter = (key: string, record: LWWRecord<any>) => void;
+declare class RepairScheduler extends EventEmitter {
+    private config;
+    private merkleManager;
+    private clusterManager;
+    private partitionService;
+    private nodeId;
+    private repairQueue;
+    private activeRepairs;
+    private scanTimer?;
+    private processTimer?;
+    private started;
+    private pendingRequests;
+    private metrics;
+    private getRecord?;
+    private setRecord?;
+    constructor(merkleManager: MerkleTreeManager, clusterManager: ClusterManager, partitionService: PartitionService, nodeId: string, config?: Partial<RepairConfig>);
+    /**
+     * Set data access callbacks
+     */
+    setDataAccessors(getRecord: RecordGetter, setRecord: RecordSetter): void;
+    /**
+     * Setup network message handlers
+     */
+    private setupNetworkHandlers;
+    /**
+     * Handle incoming cluster messages
+     */
+    private handleClusterMessage;
+    private handleMerkleRootReq;
+    private handleMerkleBucketsReq;
+    private handleMerkleKeysReq;
+    private handleRepairDataReq;
+    private handleResponse;
+    /**
+     * Start the repair scheduler
+     */
+    start(): void;
+    /**
+     * Stop the repair scheduler
+     */
+    stop(): void;
+    /**
+     * Schedule a full scan of all owned partitions
+     */
+    scheduleFullScan(): void;
+    /**
+     * Schedule repair for a specific partition
+     */
+    schedulePartitionRepair(partitionId: number, priority?: 'high' | 'normal' | 'low'): void;
+    /**
+     * Sort repair queue by priority
+     */
+    private sortRepairQueue;
+    /**
+     * Process the repair queue
+     */
+    private processRepairQueue;
+    /**
+     * Execute repair for a partition-replica pair
+     */
+    private executeRepair;
+    /**
+     * Send a request and wait for response
+     */
+    private sendRequest;
+    /**
+     * Request Merkle root from remote node
+     */
+    private requestRemoteMerkleRoot;
+    /**
+     * Find keys that differ between local and remote using bucket exchange
+     */
+    private findDifferences;
+    /**
+     * Repair a single key
+     */
+    private repairKey;
+    /**
+     * Resolve conflict between two records using LWW
+     */
+    resolveConflict<T>(a: LWWRecord<T> | undefined, b: LWWRecord<T> | undefined): LWWRecord<T> | null;
+    /**
+     * Compare two timestamps
+     */
+    private compareTimestamps;
+    /**
+     * Get partitions owned by this node
+     */
+    private getOwnedPartitions;
+    /**
+     * Get partitions where this node is a backup
+     */
+    private getReplicaPartitions;
+    /**
+     * Update average repair duration
+     */
+    private updateAverageRepairDuration;
+    /**
+     * Get repair metrics
+     */
+    getMetrics(): RepairMetrics;
+    /**
+     * Get repair queue status
+     */
+    getQueueStatus(): {
+        queueLength: number;
+        activeRepairs: number;
+        maxConcurrent: number;
+    };
+    /**
+     * Force immediate repair for a partition
+     */
+    forceRepair(partitionId: number): void;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+
 /**
  * Configuration for the processor sandbox.
  */
@@ -3872,4 +4442,4 @@ declare class MapFactory {
     getConfig(): ServerIndexConfig;
 }
 
-export { BufferPool, type BufferPoolConfig, type BufferPoolStats, type ClusterConfig, ClusterCoordinator, type ClusterCoordinatorConfig, type ClusterCoordinatorEvents, ClusterManager, type ClusterMember, type ClusterMessage, type CoalescingPreset, type CoalescingWriterMetrics, type CoalescingWriterOptions, ConflictResolverHandler, type ConflictResolverHandlerConfig, ConflictResolverService, type ConflictResolverServiceConfig, type ConnectionContext, ConnectionRateLimiter, DEFAULT_CLUSTER_COORDINATOR_CONFIG, DEFAULT_CONFLICT_RESOLVER_CONFIG, DEFAULT_INDEX_CONFIG, DEFAULT_JOURNAL_SERVICE_CONFIG, DEFAULT_LAG_TRACKER_CONFIG, DEFAULT_SANDBOX_CONFIG, EntryProcessorHandler, type EntryProcessorHandlerConfig, EventJournalService, type EventJournalServiceConfig, type ExportOptions, FilterTasklet, ForEachTasklet, type IInterceptor, type IServerStorage, type IndexDefinition, IteratorTasklet, type IteratorTaskletConfig, type LagInfo, LagTracker, type LagTrackerConfig, LockManager, type Logger, MapFactory, type MapIndexConfig, MapTasklet, MapWithResolver, type MapWithResolverConfig, MemoryServerAdapter, type MergeWithResolverResult, MigrationManager, type NativeModuleStatus, type NativeStats, type ORMapTombstones, type ORMapValue, ObjectPool, type ObjectPoolConfig, type ObjectPoolStats, type OpContext, type PartitionDistribution, PartitionService, type PartitionServiceConfig, type PartitionServiceEvents, type PooledEventPayload, type PooledMessage, type PooledRecord, type PooledTimestamp, PostgresAdapter, type PostgresAdapterOptions, ProcessorSandbox, type ProcessorSandboxConfig, type ProgressState, RateLimitInterceptor, type RateLimiterConfig, type RateLimiterStats, ReduceTasklet, ReplicationPipeline, SecurityManager, ServerCoordinator, type ServerCoordinatorConfig, type ServerIndexConfig, type ServerOp, type SetWithResolverResult, type StorageValue, type Tasklet, TaskletScheduler, type TaskletSchedulerConfig, type TaskletSchedulerStats, TimestampInterceptor, coalescingPresets, createEventPayloadPool, createMessagePool, createRecordPool, createTimestampPool, getCoalescingPreset, getGlobalBufferPool, getGlobalEventPayloadPool, getGlobalMessagePool, getGlobalRecordPool, getGlobalTimestampPool, getNativeModuleStatus, getNativeStats, logNativeStatus, logger, mergeWithDefaults, setGlobalBufferPool, setGlobalEventPayloadPool, setGlobalMessagePool, setGlobalRecordPool, setGlobalTimestampPool, validateIndexConfig };
+export { BufferPool, type BufferPoolConfig, type BufferPoolStats, type ClusterConfig, ClusterCoordinator, type ClusterCoordinatorConfig, type ClusterCoordinatorEvents, ClusterManager, type ClusterMember, type ClusterMessage, type CoalescingPreset, type CoalescingWriterMetrics, type CoalescingWriterOptions, ConflictResolverHandler, type ConflictResolverHandlerConfig, ConflictResolverService, type ConflictResolverServiceConfig, type ConnectionContext, ConnectionRateLimiter, DEFAULT_CLUSTER_COORDINATOR_CONFIG, DEFAULT_CONFLICT_RESOLVER_CONFIG, DEFAULT_FAILURE_DETECTOR_CONFIG, DEFAULT_INDEX_CONFIG, DEFAULT_JOURNAL_SERVICE_CONFIG, DEFAULT_LAG_TRACKER_CONFIG, DEFAULT_MERKLE_TREE_CONFIG, DEFAULT_READ_REPLICA_CONFIG, DEFAULT_REASSIGNER_CONFIG, DEFAULT_REPAIR_CONFIG, DEFAULT_SANDBOX_CONFIG, EntryProcessorHandler, type EntryProcessorHandlerConfig, EventJournalService, type EventJournalServiceConfig, type ExportOptions, type FailoverStatus, FailureDetector, type FailureDetectorConfig, type FailureDetectorEvents, FilterTasklet, ForEachTasklet, type IInterceptor, type IServerStorage, type IndexDefinition, IteratorTasklet, type IteratorTaskletConfig, type LagInfo, LagTracker, type LagTrackerConfig, LockManager, type Logger, MapFactory, type MapIndexConfig, MapTasklet, MapWithResolver, type MapWithResolverConfig, MemoryServerAdapter, type MergeWithResolverResult, type MerkleComparisonResult, MerkleTreeManager, type MerkleTreeManagerConfig, MigrationManager, type NativeModuleStatus, type NativeStats, type NodeState, type ORMapTombstones, type ORMapValue, ObjectPool, type ObjectPoolConfig, type ObjectPoolStats, type OpContext, type PartitionDistribution, type PartitionMerkleInfo, PartitionReassigner, type PartitionReassignerConfig, PartitionService, type PartitionServiceConfig, type PartitionServiceEvents, type PooledEventPayload, type PooledMessage, type PooledRecord, type PooledTimestamp, PostgresAdapter, type PostgresAdapterOptions, ProcessorSandbox, type ProcessorSandboxConfig, type ProgressState, RateLimitInterceptor, type RateLimiterConfig, type RateLimiterStats, type ReadReplicaConfig, ReadReplicaHandler, type ReadRequest, type ReadResult, type ReassignmentEvent, ReduceTasklet, type RepairConfig, type RepairMetrics, type RepairResult, RepairScheduler, type RepairTask, ReplicationPipeline, SecurityManager, ServerCoordinator, type ServerCoordinatorConfig, type ServerIndexConfig, type ServerOp, type SetWithResolverResult, type StorageValue, type Tasklet, TaskletScheduler, type TaskletSchedulerConfig, type TaskletSchedulerStats, TimestampInterceptor, coalescingPresets, createEventPayloadPool, createMessagePool, createRecordPool, createTimestampPool, getCoalescingPreset, getGlobalBufferPool, getGlobalEventPayloadPool, getGlobalMessagePool, getGlobalRecordPool, getGlobalTimestampPool, getNativeModuleStatus, getNativeStats, logNativeStatus, logger, mergeWithDefaults, setGlobalBufferPool, setGlobalEventPayloadPool, setGlobalMessagePool, setGlobalRecordPool, setGlobalTimestampPool, validateIndexConfig };