/**
 * @file Conflict Resolver
 * @description Advanced conflict resolution strategies for data synchronization
 * including three-way merge, field-level resolution, and vector clocks.
 *
 * Features:
 * - Multiple resolution strategies
 * - Three-way merge support
 * - Field-level conflict resolution
 * - Vector clock implementation
 * - Custom merge functions
 * - Conflict history tracking
 *
 * @example
 * ```typescript
 * import { createConflictResolver, threeWayMerge } from '@/lib/data/sync';
 *
 * const resolver = createConflictResolver({
 *   strategy: 'three-way-merge',
 *   fieldStrategies: {
 *     updatedAt: 'latest',
 *     version: 'increment',
 *   },
 * });
 *
 * const resolved = resolver.resolve(local, remote, base);
 * ```
 */
/**
 * Conflict resolution strategy
 */
export type ConflictStrategy = 'server-wins' | 'client-wins' | 'latest-wins' | 'three-way-merge' | 'field-level' | 'manual';
/**
 * Field-level resolution strategy
 */
export type FieldStrategy = 'server' | 'client' | 'latest' | 'merge' | 'concat' | 'sum' | 'max' | 'min' | 'increment' | 'custom';
/**
 * Conflict information
 */
export interface Conflict {
    /** Field path where conflict occurred */
    path: string[];
    /** Local value */
    localValue: unknown;
    /** Remote value */
    remoteValue: unknown;
    /** Base value (if available) */
    baseValue?: unknown;
    /** Local modified timestamp */
    localModifiedAt?: number;
    /** Remote modified timestamp */
    remoteModifiedAt?: number;
    /** Resolved value */
    resolvedValue?: unknown;
    /** How it was resolved */
    resolution?: string;
}
/**
 * Conflict resolution result
 */
export interface ConflictResolutionResult<T> {
    /** Merged data */
    data: T;
    /** Whether conflicts were detected */
    hasConflicts: boolean;
    /** List of conflicts */
    conflicts: Conflict[];
    /** Resolution metadata */
    metadata: {
        strategy: ConflictStrategy;
        resolvedAt: number;
        localVersion?: string;
        remoteVersion?: string;
    };
}
/**
 * Conflict resolver configuration
 */
export interface ConflictResolverConfig {
    /** Default resolution strategy */
    strategy: ConflictStrategy;
    /** Field-level strategies */
    fieldStrategies?: Record<string, FieldStrategy | ((local: unknown, remote: unknown, base?: unknown) => unknown)>;
    /** Fields to ignore in merge */
    ignoreFields?: string[];
    /** Fields that should always use server value */
    serverFields?: string[];
    /** Fields that should always use client value */
    clientFields?: string[];
    /** Timestamp field for latest-wins */
    timestampField?: string;
    /** Custom merge function */
    customMerge?: <T>(local: T, remote: T, base?: T) => T;
    /** Track conflict history */
    trackHistory?: boolean;
}
/**
 * Vector clock for distributed systems
 */
export interface VectorClock {
    [nodeId: string]: number;
}
/**
 * Conflict resolver instance
 */
export interface ConflictResolver<T = unknown> {
    /** Resolve conflict between local and remote */
    resolve: (local: T, remote: T, base?: T) => ConflictResolutionResult<T>;
    /** Get conflicts without resolving */
    detectConflicts: (local: T, remote: T, base?: T) => Conflict[];
    /** Compare vector clocks */
    compareVersions: (localClock: VectorClock, remoteClock: VectorClock) => 'equal' | 'local-newer' | 'remote-newer' | 'concurrent';
    /** Merge vector clocks */
    mergeClocks: (localClock: VectorClock, remoteClock: VectorClock) => VectorClock;
    /** Get conflict history */
    getHistory: () => ConflictResolutionResult<T>[];
    /** Clear history */
    clearHistory: () => void;
}
/**
 * Three-way merge algorithm
 */
export declare function threeWayMerge<T extends Record<string, unknown>>(local: T, remote: T, base: T, config?: {
    fieldStrategies?: Record<string, FieldStrategy>;
    ignoreFields?: string[];
}): ConflictResolutionResult<T>;
/**
 * Compare two vector clocks
 */
export declare function compareVectorClocks(a: VectorClock, b: VectorClock): 'equal' | 'a-newer' | 'b-newer' | 'concurrent';
/**
 * Merge two vector clocks
 */
export declare function mergeVectorClocks(a: VectorClock, b: VectorClock): VectorClock;
/**
 * Increment vector clock for a node
 */
export declare function incrementVectorClock(clock: VectorClock, nodeId: string): VectorClock;
/**
 * Create initial vector clock
 */
export declare function createVectorClock(nodeId: string): VectorClock;
/**
 * Create a conflict resolver
 */
export declare function createConflictResolver<T extends Record<string, unknown>>(config: ConflictResolverConfig): ConflictResolver<T>;
/**
 * Server-wins resolver
 */
export declare const serverWinsResolver: <T extends Record<string, unknown>>() => ConflictResolver<T>;
/**
 * Client-wins resolver
 */
export declare const clientWinsResolver: <T extends Record<string, unknown>>() => ConflictResolver<T>;
/**
 * Latest-wins resolver
 */
export declare const latestWinsResolver: <T extends Record<string, unknown>>(timestampField?: string) => ConflictResolver<T>;
/**
 * Three-way merge resolver
 */
export declare const threeWayMergeResolver: <T extends Record<string, unknown>>(options?: Partial<ConflictResolverConfig>) => ConflictResolver<T>;