@affectively/aeon 1.0.0 → 1.2.0

package/dist/distributed/index.d.cts

@@ -1,2 +1,901 @@
-export { H as Handshake, M as MergeStrategy, P as ProtocolError, R as ReconciliationResult, l as Replica, m as ReplicationEvent, n as ReplicationManager, o as ReplicationPolicy, s as StateDiff, t as StateReconciler, u as StateVersion, v as SyncCoordinator, w as SyncEvent, x as SyncMessage, y as SyncNode, z as SyncProtocol, B as SyncRequest, F as SyncResponse, G as SyncSession } from '../index-C_4CMV5c.cjs';
-import 'eventemitter3';
+import { EventEmitter } from 'eventemitter3';
+import { ICryptoProvider, AeonEncryptionMode, AuthenticatedMessageFields } from '../crypto/index.cjs';
+import { S as StorageAdapter, b as PersistenceSerializer, a as PersistenceDeserializer } from '../types-CMxO7QF0.cjs';
+
+/**
+ * Sync Coordinator
+ *
+ * Coordinates synchronization between multiple nodes in a distributed system.
+ * Manages sync sessions, node registration, and synchronization workflows.
+ *
+ * Features:
+ * - Node registration and discovery
+ * - Sync session management
+ * - Synchronization workflow orchestration
+ * - Node health monitoring
+ * - Conflict detection and resolution coordination
+ * - DID-based node identification
+ * - Authenticated sync sessions
+ */
+
+interface SyncNode {
+    id: string;
+    address: string;
+    port: number;
+    status: 'online' | 'offline' | 'syncing';
+    lastHeartbeat: string;
+    version: string;
+    capabilities: string[];
+    did?: string;
+    publicSigningKey?: JsonWebKey;
+    publicEncryptionKey?: JsonWebKey;
+    grantedCapabilities?: string[];
+}
+interface SyncSession {
+    id: string;
+    initiatorId: string;
+    participantIds: string[];
+    status: 'pending' | 'active' | 'completed' | 'failed';
+    startTime: string;
+    endTime?: string;
+    itemsSynced: number;
+    itemsFailed: number;
+    conflictsDetected: number;
+    initiatorDID?: string;
+    participantDIDs?: string[];
+    encryptionMode?: AeonEncryptionMode;
+    requiredCapabilities?: string[];
+    sessionToken?: string;
+}
+interface SyncEvent {
+    type: 'node-joined' | 'node-left' | 'sync-started' | 'sync-completed' | 'conflict-detected';
+    sessionId?: string;
+    nodeId: string;
+    timestamp: string;
+    data?: unknown;
+}
+/**
+ * Sync Coordinator
+ * Coordinates synchronization across distributed nodes
+ */
+declare class SyncCoordinator extends EventEmitter {
+    private nodes;
+    private sessions;
+    private syncEvents;
+    private nodeHeartbeats;
+    private heartbeatInterval;
+    private cryptoProvider;
+    private nodesByDID;
+    constructor();
+    /**
+     * Configure cryptographic provider for authenticated sync
+     */
+    configureCrypto(provider: ICryptoProvider): void;
+    /**
+     * Check if crypto is configured
+     */
+    isCryptoEnabled(): boolean;
+    /**
+     * Register a node with DID-based identity
+     */
+    registerAuthenticatedNode(nodeInfo: Omit<SyncNode, 'did' | 'publicSigningKey' | 'publicEncryptionKey'> & {
+        did: string;
+        publicSigningKey: JsonWebKey;
+        publicEncryptionKey?: JsonWebKey;
+    }): Promise<SyncNode>;
+    /**
+     * Get node by DID
+     */
+    getNodeByDID(did: string): SyncNode | undefined;
+    /**
+     * Get all authenticated nodes (nodes with DIDs)
+     */
+    getAuthenticatedNodes(): SyncNode[];
+    /**
+     * Create an authenticated sync session with UCAN-based authorization
+     */
+    createAuthenticatedSyncSession(initiatorDID: string, participantDIDs: string[], options?: {
+        encryptionMode?: AeonEncryptionMode;
+        requiredCapabilities?: string[];
+    }): Promise<SyncSession>;
+    /**
+     * Verify a node's UCAN capabilities for a session
+     */
+    verifyNodeCapabilities(sessionId: string, nodeDID: string, token: string): Promise<{
+        authorized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Register a node in the cluster
+     */
+    registerNode(node: SyncNode): void;
+    /**
+     * Deregister a node from the cluster
+     */
+    deregisterNode(nodeId: string): void;
+    /**
+     * Create a new sync session
+     */
+    createSyncSession(initiatorId: string, participantIds: string[]): SyncSession;
+    /**
+     * Update sync session
+     */
+    updateSyncSession(sessionId: string, updates: Partial<SyncSession>): void;
+    /**
+     * Record a conflict during sync
+     */
+    recordConflict(sessionId: string, nodeId: string, conflictData?: unknown): void;
+    /**
+     * Update node status
+     */
+    updateNodeStatus(nodeId: string, status: SyncNode['status']): void;
+    /**
+     * Record heartbeat from node
+     */
+    recordHeartbeat(nodeId: string): void;
+    /**
+     * Get all nodes
+     */
+    getNodes(): SyncNode[];
+    /**
+     * Get node by ID
+     */
+    getNode(nodeId: string): SyncNode | undefined;
+    /**
+     * Get online nodes
+     */
+    getOnlineNodes(): SyncNode[];
+    /**
+     * Get nodes by capability
+     */
+    getNodesByCapability(capability: string): SyncNode[];
+    /**
+     * Get sync session
+     */
+    getSyncSession(sessionId: string): SyncSession | undefined;
+    /**
+     * Get all sync sessions
+     */
+    getAllSyncSessions(): SyncSession[];
+    /**
+     * Get active sync sessions
+     */
+    getActiveSyncSessions(): SyncSession[];
+    /**
+     * Get sessions for a node
+     */
+    getSessionsForNode(nodeId: string): SyncSession[];
+    /**
+     * Get sync statistics
+     */
+    getStatistics(): {
+        totalNodes: number;
+        onlineNodes: number;
+        offlineNodes: number;
+        totalSessions: number;
+        activeSessions: number;
+        completedSessions: number;
+        failedSessions: number;
+        successRate: number;
+        totalItemsSynced: number;
+        totalConflicts: number;
+        averageConflictsPerSession: number;
+    };
+    /**
+     * Get sync events
+     */
+    getSyncEvents(limit?: number): SyncEvent[];
+    /**
+     * Get sync events for session
+     */
+    getSessionEvents(sessionId: string): SyncEvent[];
+    /**
+     * Check node health
+     */
+    getNodeHealth(): Record<string, {
+        isHealthy: boolean;
+        downtime: number;
+    }>;
+    /**
+     * Start heartbeat monitoring
+     */
+    startHeartbeatMonitoring(interval?: number): void;
+    /**
+     * Stop heartbeat monitoring
+     */
+    stopHeartbeatMonitoring(): void;
+    /**
+     * Clear all state (for testing)
+     */
+    clear(): void;
+    /**
+     * Get the crypto provider (for advanced usage)
+     */
+    getCryptoProvider(): ICryptoProvider | null;
+}
+
+/**
+ * Replication Manager
+ *
+ * Manages data replication across multiple nodes.
+ * Handles replication policies, consistency levels, and replica coordination.
+ *
+ * Features:
+ * - Replica set management
+ * - Replication policy enforcement
+ * - Consistency level tracking
+ * - Replication health monitoring
+ * - Replica synchronization coordination
+ * - End-to-end encryption for replicated data
+ * - DID-based replica authentication
+ */
+
+interface Replica {
+    id: string;
+    nodeId: string;
+    status: 'primary' | 'secondary' | 'syncing' | 'failed';
+    lastSyncTime: string;
+    lagBytes: number;
+    lagMillis: number;
+    did?: string;
+    encrypted?: boolean;
+}
+interface ReplicationPolicy {
+    id: string;
+    name: string;
+    replicationFactor: number;
+    consistencyLevel: 'eventual' | 'read-after-write' | 'strong';
+    syncInterval: number;
+    maxReplicationLag: number;
+    encryptionMode?: AeonEncryptionMode;
+    requiredCapabilities?: string[];
+}
+interface ReplicationEvent {
+    type: 'replica-added' | 'replica-removed' | 'replica-synced' | 'sync-failed';
+    replicaId: string;
+    nodeId: string;
+    timestamp: string;
+    details?: unknown;
+}
+/**
+ * Encrypted replication data envelope
+ */
+interface EncryptedReplicationData {
+    /** Encrypted ciphertext (base64) */
+    ct: string;
+    /** Initialization vector (base64) */
+    iv: string;
+    /** Authentication tag (base64) */
+    tag: string;
+    /** Ephemeral public key for ECIES */
+    epk?: JsonWebKey;
+    /** Sender DID */
+    senderDID?: string;
+    /** Target replica DID */
+    targetDID?: string;
+    /** Encryption timestamp */
+    encryptedAt: number;
+}
+interface ReplicationPersistenceData {
+    replicas: Replica[];
+    policies: ReplicationPolicy[];
+    syncStatus: Array<{
+        nodeId: string;
+        synced: number;
+        failed: number;
+    }>;
+}
+interface ReplicationPersistenceConfig {
+    adapter: StorageAdapter;
+    key?: string;
+    autoPersist?: boolean;
+    autoLoad?: boolean;
+    persistDebounceMs?: number;
+    serializer?: PersistenceSerializer<ReplicationPersistenceData>;
+    deserializer?: PersistenceDeserializer<ReplicationPersistenceData>;
+}
+interface ReplicationManagerOptions {
+    persistence?: ReplicationPersistenceConfig;
+}
+/**
+ * Replication Manager
+ * Manages data replication across distributed nodes
+ */
+declare class ReplicationManager {
+    private static readonly DEFAULT_PERSIST_KEY;
+    private replicas;
+    private policies;
+    private replicationEvents;
+    private syncStatus;
+    private cryptoProvider;
+    private replicasByDID;
+    private persistence;
+    private persistTimer;
+    private persistInFlight;
+    private persistPending;
+    constructor(options?: ReplicationManagerOptions);
+    /**
+     * Configure cryptographic provider for encrypted replication
+     */
+    configureCrypto(provider: ICryptoProvider): void;
+    /**
+     * Check if crypto is configured
+     */
+    isCryptoEnabled(): boolean;
+    /**
+     * Register an authenticated replica with DID
+     */
+    registerAuthenticatedReplica(replica: Omit<Replica, 'did' | 'encrypted'> & {
+        did: string;
+        publicSigningKey?: JsonWebKey;
+        publicEncryptionKey?: JsonWebKey;
+    }, encrypted?: boolean): Promise<Replica>;
+    /**
+     * Get replica by DID
+     */
+    getReplicaByDID(did: string): Replica | undefined;
+    /**
+     * Get all encrypted replicas
+     */
+    getEncryptedReplicas(): Replica[];
+    /**
+     * Encrypt data for replication to a specific replica
+     */
+    encryptForReplica(data: unknown, targetReplicaDID: string): Promise<EncryptedReplicationData>;
+    /**
+     * Decrypt data received from replication
+     */
+    decryptReplicationData<T>(encrypted: EncryptedReplicationData): Promise<T>;
+    /**
+     * Create an encrypted replication policy
+     */
+    createEncryptedPolicy(name: string, replicationFactor: number, consistencyLevel: 'eventual' | 'read-after-write' | 'strong', encryptionMode: AeonEncryptionMode, options?: {
+        syncInterval?: number;
+        maxReplicationLag?: number;
+        requiredCapabilities?: string[];
+    }): ReplicationPolicy;
+    /**
+     * Verify a replica's capabilities via UCAN
+     */
+    verifyReplicaCapabilities(replicaDID: string, token: string, policyId?: string): Promise<{
+        authorized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Register a replica
+     */
+    registerReplica(replica: Replica): void;
+    /**
+     * Remove a replica
+     */
+    removeReplica(replicaId: string): void;
+    /**
+     * Create a replication policy
+     */
+    createPolicy(name: string, replicationFactor: number, consistencyLevel: 'eventual' | 'read-after-write' | 'strong', syncInterval?: number, maxReplicationLag?: number): ReplicationPolicy;
+    /**
+     * Update replica status
+     */
+    updateReplicaStatus(replicaId: string, status: Replica['status'], lagBytes?: number, lagMillis?: number): void;
+    /**
+     * Get replicas for node
+     */
+    getReplicasForNode(nodeId: string): Replica[];
+    /**
+     * Get healthy replicas
+     */
+    getHealthyReplicas(): Replica[];
+    /**
+     * Get syncing replicas
+     */
+    getSyncingReplicas(): Replica[];
+    /**
+     * Get failed replicas
+     */
+    getFailedReplicas(): Replica[];
+    /**
+     * Check replication health for policy
+     */
+    checkReplicationHealth(policyId: string): {
+        healthy: boolean;
+        replicasInPolicy: number;
+        healthyReplicas: number;
+        replicationLag: number;
+    };
+    /**
+     * Get consistency level
+     */
+    getConsistencyLevel(policyId: string): 'eventual' | 'read-after-write' | 'strong';
+    /**
+     * Get replica
+     */
+    getReplica(replicaId: string): Replica | undefined;
+    /**
+     * Get all replicas
+     */
+    getAllReplicas(): Replica[];
+    /**
+     * Get policy
+     */
+    getPolicy(policyId: string): ReplicationPolicy | undefined;
+    /**
+     * Get all policies
+     */
+    getAllPolicies(): ReplicationPolicy[];
+    /**
+     * Get replication statistics
+     */
+    getStatistics(): {
+        totalReplicas: number;
+        healthyReplicas: number;
+        syncingReplicas: number;
+        failedReplicas: number;
+        healthiness: number;
+        averageReplicationLagMs: number;
+        maxReplicationLagMs: number;
+        totalPolicies: number;
+    };
+    /**
+     * Get replication events
+     */
+    getReplicationEvents(limit?: number): ReplicationEvent[];
+    /**
+     * Get sync status for node
+     */
+    getSyncStatus(nodeId: string): {
+        synced: number;
+        failed: number;
+    };
+    /**
+     * Get replication lag distribution
+     */
+    getReplicationLagDistribution(): Record<string, number>;
+    /**
+     * Check if can satisfy consistency level
+     */
+    canSatisfyConsistency(policyId: string, _requiredAcks: number): boolean;
+    /**
+     * Persist current replication state snapshot.
+     */
+    saveToPersistence(): Promise<void>;
+    /**
+     * Load replication snapshot from persistence.
+     */
+    loadFromPersistence(): Promise<{
+        replicas: number;
+        policies: number;
+        syncStatus: number;
+    }>;
+    /**
+     * Remove persisted replication snapshot.
+     */
+    clearPersistence(): Promise<void>;
+    private schedulePersist;
+    private persistSafely;
+    private isValidReplica;
+    private isValidPolicy;
+    /**
+     * Clear all state (for testing)
+     */
+    clear(): void;
+    /**
+     * Get the crypto provider (for advanced usage)
+     */
+    getCryptoProvider(): ICryptoProvider | null;
+}
+
+/**
+ * Sync Protocol
+ *
+ * Handles synchronization protocol messages and handshaking.
+ * Manages message serialization, protocol versioning, and compatibility.
+ *
+ * Features:
+ * - Message serialization and deserialization
+ * - Protocol version management
+ * - Handshake handling
+ * - Message validation and error handling
+ * - Protocol state machine
+ * - Optional cryptographic authentication and encryption
+ */
+
+interface SyncMessage {
+    type: 'handshake' | 'sync-request' | 'sync-response' | 'ack' | 'error';
+    version: string;
+    sender: string;
+    receiver: string;
+    messageId: string;
+    timestamp: string;
+    payload?: unknown;
+    auth?: AuthenticatedMessageFields;
+}
+interface Handshake {
+    protocolVersion: string;
+    nodeId: string;
+    capabilities: string[];
+    state: 'initiating' | 'responding' | 'completed';
+    did?: string;
+    publicSigningKey?: JsonWebKey;
+    publicEncryptionKey?: JsonWebKey;
+    ucan?: string;
+}
+/**
+ * Crypto configuration for sync protocol
+ */
+interface SyncProtocolCryptoConfig {
+    /** Encryption mode for messages */
+    encryptionMode: AeonEncryptionMode;
+    /** Require all messages to be signed */
+    requireSignatures: boolean;
+    /** Require UCAN capability verification */
+    requireCapabilities: boolean;
+    /** Required capabilities for sync operations */
+    requiredCapabilities?: Array<{
+        can: string;
+        with: string;
+    }>;
+}
+interface SyncRequest {
+    sessionId: string;
+    fromVersion: string;
+    toVersion: string;
+    filter?: Record<string, unknown>;
+}
+interface SyncResponse {
+    sessionId: string;
+    fromVersion: string;
+    toVersion: string;
+    data: unknown[];
+    hasMore: boolean;
+    offset: number;
+}
+interface ProtocolError {
+    code: string;
+    message: string;
+    recoverable: boolean;
+}
+interface SyncProtocolPersistenceData {
+    protocolVersion: string;
+    messageCounter: number;
+    messageQueue: SyncMessage[];
+    handshakes: Array<{
+        nodeId: string;
+        handshake: Handshake;
+    }>;
+    protocolErrors: Array<{
+        error: ProtocolError;
+        timestamp: string;
+    }>;
+}
+interface SyncProtocolPersistenceConfig {
+    adapter: StorageAdapter;
+    key?: string;
+    autoPersist?: boolean;
+    autoLoad?: boolean;
+    persistDebounceMs?: number;
+    serializer?: PersistenceSerializer<SyncProtocolPersistenceData>;
+    deserializer?: PersistenceDeserializer<SyncProtocolPersistenceData>;
+}
+interface SyncProtocolOptions {
+    persistence?: SyncProtocolPersistenceConfig;
+}
+/**
+ * Sync Protocol
+ * Handles synchronization protocol messages and handshaking
+ */
+declare class SyncProtocol {
+    private static readonly DEFAULT_PERSIST_KEY;
+    private version;
+    private messageQueue;
+    private messageMap;
+    private handshakes;
+    private protocolErrors;
+    private messageCounter;
+    private cryptoProvider;
+    private cryptoConfig;
+    private persistence;
+    private persistTimer;
+    private persistInFlight;
+    private persistPending;
+    constructor(options?: SyncProtocolOptions);
+    /**
+     * Configure cryptographic provider for authenticated/encrypted messages
+     */
+    configureCrypto(provider: ICryptoProvider, config?: Partial<SyncProtocolCryptoConfig>): void;
+    /**
+     * Check if crypto is configured
+     */
+    isCryptoEnabled(): boolean;
+    /**
+     * Get crypto configuration
+     */
+    getCryptoConfig(): SyncProtocolCryptoConfig | null;
+    /**
+     * Get protocol version
+     */
+    getVersion(): string;
+    /**
+     * Create authenticated handshake message with DID and keys
+     */
+    createAuthenticatedHandshake(capabilities: string[], targetDID?: string): Promise<SyncMessage>;
+    /**
+     * Verify and process an authenticated handshake
+     */
+    verifyAuthenticatedHandshake(message: SyncMessage): Promise<{
+        valid: boolean;
+        handshake?: Handshake;
+        error?: string;
+    }>;
+    /**
+     * Sign and optionally encrypt a message payload
+     */
+    signMessage<T>(message: SyncMessage, payload: T, encrypt?: boolean): Promise<SyncMessage>;
+    /**
+     * Verify signature and optionally decrypt a message
+     */
+    verifyMessage<T>(message: SyncMessage): Promise<{
+        valid: boolean;
+        payload?: T;
+        error?: string;
+    }>;
+    /**
+     * Create handshake message
+     */
+    createHandshakeMessage(nodeId: string, capabilities: string[]): SyncMessage;
+    /**
+     * Create sync request message
+     */
+    createSyncRequestMessage(sender: string, receiver: string, sessionId: string, fromVersion: string, toVersion: string, filter?: Record<string, unknown>): SyncMessage;
+    /**
+     * Create sync response message
+     */
+    createSyncResponseMessage(sender: string, receiver: string, sessionId: string, fromVersion: string, toVersion: string, data: unknown[], hasMore?: boolean, offset?: number): SyncMessage;
+    /**
+     * Create acknowledgement message
+     */
+    createAckMessage(sender: string, receiver: string, messageId: string): SyncMessage;
+    /**
+     * Create error message
+     */
+    createErrorMessage(sender: string, receiver: string, error: ProtocolError, relatedMessageId?: string): SyncMessage;
+    /**
+     * Validate message
+     */
+    validateMessage(message: SyncMessage): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Serialize message
+     */
+    serializeMessage(message: SyncMessage): string;
+    /**
+     * Deserialize message
+     */
+    deserializeMessage(data: string): SyncMessage;
+    /**
+     * Process handshake
+     */
+    processHandshake(message: SyncMessage): Handshake;
+    /**
+     * Get message
+     */
+    getMessage(messageId: string): SyncMessage | undefined;
+    /**
+     * Get all messages
+     */
+    getAllMessages(): SyncMessage[];
+    /**
+     * Get messages by type
+     */
+    getMessagesByType(type: SyncMessage['type']): SyncMessage[];
+    /**
+     * Get messages from sender
+     */
+    getMessagesFromSender(sender: string): SyncMessage[];
+    /**
+     * Get pending messages
+     */
+    getPendingMessages(receiver: string): SyncMessage[];
+    /**
+     * Get handshakes
+     */
+    getHandshakes(): Map<string, Handshake>;
+    /**
+     * Get protocol statistics
+     */
+    getStatistics(): {
+        totalMessages: number;
+        messagesByType: Record<string, number>;
+        totalHandshakes: number;
+        totalErrors: number;
+        recoverableErrors: number;
+        unrecoverableErrors: number;
+    };
+    /**
+     * Get protocol errors
+     */
+    getErrors(): Array<{
+        error: ProtocolError;
+        timestamp: string;
+    }>;
+    /**
+     * Persist protocol state for reconnect/replay.
+     */
+    saveToPersistence(): Promise<void>;
+    /**
+     * Load protocol state from persistence.
+     */
+    loadFromPersistence(): Promise<{
+        messages: number;
+        handshakes: number;
+        errors: number;
+    }>;
+    /**
+     * Clear persisted protocol checkpoint.
+     */
+    clearPersistence(): Promise<void>;
+    private schedulePersist;
+    private persistSafely;
+    private isValidHandshake;
+    private isValidProtocolErrorEntry;
+    /**
+     * Generate message ID
+     */
+    private generateMessageId;
+    /**
+     * Clear all state (for testing)
+     */
+    clear(): void;
+    /**
+     * Get the crypto provider (for advanced usage)
+     */
+    getCryptoProvider(): ICryptoProvider | null;
+}
+
+/**
+ * State Reconciler
+ *
+ * Reconciles conflicting state across multiple nodes in a distributed system.
+ * Applies merge strategies and resolves divergent state.
+ *
+ * Features:
+ * - State comparison and diff generation
+ * - Multiple merge strategies (last-write-wins, vector-clock based, custom)
+ * - Conflict detection and resolution
+ * - State validation and verification
+ * - Version tracking
+ * - Cryptographic verification of state versions
+ * - Signed state for tamper detection
+ */
+
+interface StateVersion {
+    version: string;
+    timestamp: string;
+    nodeId: string;
+    hash: string;
+    data: unknown;
+    signerDID?: string;
+    signature?: string;
+    signedAt?: number;
+}
+interface StateDiff {
+    added: Record<string, unknown>;
+    modified: Record<string, {
+        old: unknown;
+        new: unknown;
+    }>;
+    removed: string[];
+    timestamp: string;
+}
+interface ReconciliationResult {
+    success: boolean;
+    mergedState: unknown;
+    conflictsResolved: number;
+    strategy: string;
+    timestamp: string;
+}
+type MergeStrategy = 'last-write-wins' | 'vector-clock' | 'majority-vote' | 'custom';
+/**
+ * State Reconciler
+ * Reconciles state conflicts across distributed nodes
+ */
+declare class StateReconciler {
+    private stateVersions;
+    private reconciliationHistory;
+    private cryptoProvider;
+    private requireSignedVersions;
+    /**
+     * Configure cryptographic provider for signed state versions
+     */
+    configureCrypto(provider: ICryptoProvider, requireSigned?: boolean): void;
+    /**
+     * Check if crypto is configured
+     */
+    isCryptoEnabled(): boolean;
+    /**
+     * Record a signed state version with cryptographic verification
+     */
+    recordSignedStateVersion(key: string, version: string, data: unknown): Promise<StateVersion>;
+    /**
+     * Verify a state version's signature
+     */
+    verifyStateVersion(version: StateVersion): Promise<{
+        valid: boolean;
+        error?: string;
+    }>;
+    /**
+     * Reconcile with verification - only accept verified versions
+     */
+    reconcileWithVerification(key: string, strategy?: MergeStrategy): Promise<ReconciliationResult & {
+        verificationErrors: string[];
+    }>;
+    /**
+     * Record a state version
+     */
+    recordStateVersion(key: string, version: string, timestamp: string, nodeId: string, hash: string, data: unknown): void;
+    /**
+     * Detect conflicts in state versions
+     */
+    detectConflicts(key: string): boolean;
+    /**
+     * Compare two states and generate diff
+     */
+    compareStates(state1: Record<string, unknown>, state2: Record<string, unknown>): StateDiff;
+    /**
+     * Reconcile states using last-write-wins strategy
+     */
+    reconcileLastWriteWins(versions: StateVersion[]): ReconciliationResult;
+    /**
+     * Reconcile states using vector clock strategy
+     */
+    reconcileVectorClock(versions: StateVersion[]): ReconciliationResult;
+    /**
+     * Reconcile states using majority vote strategy
+     */
+    reconcileMajorityVote(versions: StateVersion[]): ReconciliationResult;
+    /**
+     * Merge multiple states
+     */
+    mergeStates(states: Record<string, unknown>[]): unknown;
+    /**
+     * Validate state after reconciliation
+     */
+    validateState(state: unknown): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get state versions for a key
+     */
+    getStateVersions(key: string): StateVersion[];
+    /**
+     * Get all state versions
+     */
+    getAllStateVersions(): Record<string, StateVersion[]>;
+    /**
+     * Get reconciliation history
+     */
+    getReconciliationHistory(): ReconciliationResult[];
+    /**
+     * Get reconciliation statistics
+     */
+    getStatistics(): {
+        totalReconciliations: number;
+        successfulReconciliations: number;
+        totalConflictsResolved: number;
+        averageConflictsPerReconciliation: number;
+        strategyUsage: Record<string, number>;
+        trackedKeys: number;
+    };
+    /**
+     * Clear all state (for testing)
+     */
+    clear(): void;
+    /**
+     * Get the crypto provider (for advanced usage)
+     */
+    getCryptoProvider(): ICryptoProvider | null;
+}
+
+export { type Handshake, type MergeStrategy, type ProtocolError, type ReconciliationResult, type Replica, type ReplicationEvent, ReplicationManager, type ReplicationManagerOptions, type ReplicationPersistenceConfig, type ReplicationPersistenceData, type ReplicationPolicy, type StateDiff, StateReconciler, type StateVersion, SyncCoordinator, type SyncEvent, type SyncMessage, type SyncNode, SyncProtocol, type SyncProtocolOptions, type SyncProtocolPersistenceConfig, type SyncProtocolPersistenceData, type SyncRequest, type SyncResponse, type SyncSession };