import { CompareParser } from './CompareParser';
import { CompareRegistry } from './CompareRegistry';
import { CompareError, CompareDetail, CompareOptions, CompareContext } from './types';
/**
 * Recursive deep comparer for objects and arrays
 *
 * Handles:
 * - Objects (partial and exact matching)
 * - Arrays (ordered, unordered, partial)
 * - Primitives (strings, numbers, booleans)
 * - Compare directives
 * - Special keywords (exact, ignore, ignoreRest, ignoreOrder)
 */
export declare class RecursiveComparer {
    private parser;
    private registry;
    private errors;
    private details;
    private currentDepth;
    private maxDepthReached;
    constructor(parser: CompareParser, registry: CompareRegistry);
    /**
     * Compare two values recursively
     */
    compare(expected: any, actual: any, path: string[], context: CompareContext, options: CompareOptions): Promise<{
        errors: CompareError[];
        details: CompareDetail[];
        maxDepthReached: number;
    }>;
    /**
     * Internal recursive comparison
     */
    private compareInternal;
    /**
     * Compare with a compare directive
     */
    private compareWithDirective;
    /**
     * Compare two objects
     */
    private compareObjects;
    /**
     * Compare two arrays
     */
    private compareArrays;
    /**
     * Compare arrays in order
     */
    private compareArraysOrdered;
    /**
     * Compare arrays ignoring order (set-like comparison)
     */
    private compareArraysUnordered;
    /**
     * Compare arrays with partial matching (ignoreRest)
     */
    private compareArraysPartial;
    /**
     * Test if two values match (for unordered array comparison)
     */
    private testMatch;
    /**
     * Compare primitive values
     */
    private comparePrimitives;
    /**
     * Add an error
     */
    private addError;
    /**
     * Add a detail
     */
    private addDetail;
    /**
     * Check if the current path should be ignored based on ignorePaths config.
     * Returns the matching IgnorePathConfig if found, undefined otherwise.
     *
     * A path matches if:
     * - The ignorePath is equal in length or shorter than currentPath
     * - All segments of the ignorePath match the corresponding currentPath segments
     * - '*' in ignorePath matches any segment (including array indices like '[0]')
     */
    private shouldIgnorePath;
}
//# sourceMappingURL=RecursiveComparer.d.ts.map