/**
 * @nahisaho/yata-scale - Sync Controller
 *
 * Coordinates synchronization between nodes
 */
import { type Result } from 'neverthrow';
import type { SyncSession, Entity, Relationship } from '../types.js';
import { SyncError, SyncConnectionError } from '../errors.js';
import { VectorClock } from './VectorClock.js';
import { ConflictResolver, type ResolutionStrategy } from './ConflictResolver.js';
import { WALManager } from './WALManager.js';
/**
 * Sync state
 */
export type SyncState = 'idle' | 'syncing' | 'conflict' | 'error';
/**
 * Sync delta
 */
export interface SyncDelta {
    readonly entities: Entity[];
    readonly relationships: Relationship[];
    readonly deletedEntityIds: string[];
    readonly deletedRelationshipIds: string[];
    readonly vectorClock: Record<string, number>;
}
/**
 * Peer connection
 */
export interface PeerConnection {
    readonly peerId: string;
    readonly endpoint: string;
    readonly lastSyncTime?: Date;
    readonly vectorClock: VectorClock;
}
/**
 * Sync result
 */
export interface SyncResult {
    readonly success: boolean;
    readonly entitiesSynced: number;
    readonly relationshipsSynced: number;
    readonly conflictsResolved: number;
    readonly errors: string[];
    readonly duration: number;
}
/**
 * Sync controller for managing distributed synchronization
 */
export declare class SyncController {
    private readonly nodeId;
    private readonly wal;
    private readonly conflictResolver;
    private readonly vectorClock;
    private state;
    private activeSessions;
    private peers;
    constructor(nodeId: string, resolutionStrategy?: ResolutionStrategy);
    /**
     * Register a peer
     */
    registerPeer(peerId: string, endpoint: string): void;
    /**
     * Unregister a peer
     */
    unregisterPeer(peerId: string): void;
    /**
     * Record entity create
     */
    recordCreate(entity: Entity): void;
    /**
     * Record entity update
     */
    recordUpdate(entity: Entity, previous?: Entity): void;
    /**
     * Record entity delete
     */
    recordDelete(entityId: string, previous?: Entity): void;
    /**
     * Record relationship create
     */
    recordRelationshipCreate(relationship: Relationship): void;
    /**
     * Record relationship update
     */
    recordRelationshipUpdate(relationship: Relationship, previous?: Relationship): void;
    /**
     * Record relationship delete
     */
    recordRelationshipDelete(relationshipId: string, previous?: Relationship): void;
    /**
     * Get local delta since a sequence number
     */
    getLocalDelta(sinceSequence: number): SyncDelta;
    /**
     * Apply remote delta
     */
    applyRemoteDelta(delta: SyncDelta, localEntities: Map<string, Entity>, localRelationships: Map<string, Relationship>): Result<SyncResult, SyncError>;
    /**
     * Start sync session with peer
     */
    startSession(peerId: string): Result<SyncSession, SyncConnectionError>;
    /**
     * End sync session
     */
    endSession(peerId: string): void;
    /**
     * Get current sync state
     */
    getState(): SyncState;
    /**
     * Get vector clock
     */
    getVectorClock(): VectorClock;
    /**
     * Get WAL manager
     */
    getWAL(): WALManager;
    /**
     * Get conflict resolver
     */
    getConflictResolver(): ConflictResolver;
    /**
     * Get active sessions
     */
    getActiveSessions(): SyncSession[];
    /**
     * Get registered peers
     */
    getPeers(): PeerConnection[];
    /**
     * Get node ID
     */
    getNodeId(): string;
    /**
     * Get sync statistics
     */
    getStats(): {
        nodeId: string;
        state: SyncState;
        activeSessions: number;
        registeredPeers: number;
        walSequence: number;
        vectorClock: Record<string, number>;
    };
    /**
     * Reset sync state
     */
    reset(): void;
}
//# sourceMappingURL=SyncController.d.ts.map