/**
 * @nahisaho/yata-scale - Sync Controller
 *
 * Handles synchronization between nodes
 */
import { type Result } from 'neverthrow';
import type { Entity, Relationship, ConflictStrategy, SyncSession, SyncChange, WALEntry } from './types.js';
import { SyncError } from './errors.js';
/**
 * Vector clock for causality tracking
 */
export declare class VectorClock {
    private clock;
    private nodeId;
    constructor(nodeId: string);
    increment(): void;
    get(nodeId: string): number;
    merge(other: VectorClock): void;
    compare(other: VectorClock): 'before' | 'after' | 'concurrent' | 'equal';
    clone(): VectorClock;
    entries(): Map<string, number>;
    serialize(): string;
    static deserialize(data: string): VectorClock;
}
/**
 * Conflict resolver
 */
export declare class ConflictResolver {
    private strategy;
    private customResolver?;
    constructor(strategy: ConflictStrategy, customResolver?: (local: Entity, remote: Entity) => Entity);
    resolve(local: Entity, remote: Entity): Result<Entity, SyncError>;
}
/**
 * Write-ahead log manager
 */
export declare class WALManager {
    private entries;
    private sequence;
    readonly maxSegmentSize: number;
    private maxSegments;
    constructor(config: {
        maxSegmentSize: number;
        maxSegments: number;
    });
    append(operation: string, data: Record<string, unknown>): Result<number, SyncError>;
    read(fromSeq: number, toSeq: number): WALEntry[];
    readFrom(sequence: number): WALEntry[];
    replay(callback: (entry: WALEntry) => void): void;
    truncateBefore(sequence: number): void;
    get latestSequence(): number;
    getStats(): {
        entryCount: number;
        segmentCount: number;
    };
    clear(): void;
    private calculateChecksum;
}
/**
 * Sync controller
 */
export declare class SyncController {
    private nodeId;
    private clock;
    private wal;
    readonly resolver: ConflictResolver;
    private sessions;
    private peers;
    private changes;
    constructor(nodeId: string, strategy?: ConflictStrategy);
    recordCreate(entity: Entity): void;
    recordUpdate(entity: Entity, _before: Entity): void;
    recordDelete(entityId: string, _entity: Entity): void;
    recordRelationshipCreate(rel: Relationship): void;
    recordRelationshipDelete(relId: string): void;
    startSession(peerId: string): Result<SyncSession, SyncError>;
    endSession(sessionId: string): void;
    getChanges(fromSequence: number): SyncChange[];
    getDelta(_peerId: string, fromSequence: number): {
        changes: SyncChange[];
        clock: VectorClock;
    };
    applyDelta(delta: {
        peerId: string;
        changes: SyncChange[];
        clock: VectorClock;
    }): Result<void, SyncError>;
    registerPeer(peerId: string, info: {
        lastSync: Date;
        status: string;
    }): void;
    unregisterPeer(peerId: string): void;
    getPeers(): string[];
    getClock(): VectorClock;
    getStats(): {
        nodeId: string;
        activeSessions: number;
        walSequence: number;
        peerCount: number;
    };
}
//# sourceMappingURL=SyncController.d.ts.map