import { type FieldOfType } from '../key';
import { type EqualityComparatorFunction } from '../value/comparator';
import { type FilterFromPOJOFunction } from './object.filter.pojo';
/**
 * Performs a deep equality comparison between two values.
 *
 * Recursively compares arrays, objects, Maps, Sets, primitives, and Dates.
 *
 * @param a - First value to compare
 * @param b - Second value to compare
 * @returns `true` if the values are deeply equal
 */
export declare function areEqualPOJOValues<F>(a: F, b: F): boolean;
/**
 * Performs a deep equality comparison with a POJO filter applied to each value before comparison.
 *
 * Recursively compares arrays, objects, Maps, Sets, primitives, and Dates.
 *
 * @param a - First value to compare
 * @param b - Second value to compare
 * @param pojoFilter - Filter function applied to each value before comparison
 * @returns `true` if the filtered values are deeply equal
 */
export declare function areEqualPOJOValuesUsingPojoFilter<F>(a: F, b: F, pojoFilter: FilterFromPOJOFunction<F>): boolean;
/**
 * Configuration for an ObjectFieldEqualityChecker.
 */
export interface ObjectFieldEqualityCheckerConfig<T extends object> {
    /**
     * Fields to capture as part of the compressor.
     */
    readonly fields: (ObjectFieldEqualityCheckerFieldConfig<T, FieldOfType<T>> | FieldOfType<T>)[];
    /**
     * Default equality function to use when a field's equality function is not provided.
     */
    readonly defaultEqualityFunction?: EqualityComparatorFunction<unknown>;
}
/**
 * Field configration for a single field of a ObjectFieldEqualityCheckerConfig.
 */
export interface ObjectFieldEqualityCheckerFieldConfig<T extends object, K extends FieldOfType<T>> {
    /**
     * Field name to compare.
     */
    readonly fieldName: K;
    /**
     * Custom equality comparator for the field.
     */
    readonly isEqual: EqualityComparatorFunction<T[K]>;
}
/**
 * Results of an ObjectFieldEqualityChecker.
 */
export interface ObjectFieldEqualityCheckResults<T extends object> {
    /**
     * First compared object.
     */
    readonly a: T;
    /**
     * Second compared object.
     */
    readonly b: T;
    /**
     * Returns true if the object has no unequal fields.
     */
    readonly isEqual: boolean;
    /**
     * Fields that are considered equal.
     */
    readonly equalFields: FieldOfType<T>[];
    /**
     * Fields that are considered unequal.
     */
    readonly unequalFields: FieldOfType<T>[];
}
/**
 * Function used to check if two objects are considered equal.
 */
export type ObjectFieldEqualityChecker<T extends object> = ((a: Partial<T>, b: Partial<T>) => ObjectFieldEqualityCheckResults<T>) & {
    readonly _fields: Map<keyof T, ObjectFieldEqualityCheckerFieldConfig<T, FieldOfType<T>>>;
};
/**
 * Creates an {@link ObjectFieldEqualityChecker} that compares two objects field-by-field using configured equality functions.
 *
 * Fields can be specified as simple field names (using the default `===` comparator) or as config objects with custom comparators.
 *
 * @param config - Configuration with the fields to compare and an optional default equality function
 * @returns A function that compares two objects and reports which fields are equal/unequal
 */
export declare function objectFieldEqualityChecker<T extends object>(config: ObjectFieldEqualityCheckerConfig<T>): ObjectFieldEqualityChecker<T>;