import { type MergeOptions } from './merge.ts';
export type AnyConstructor = ({
    new (...args: any[]): any;
});
export interface HandleCloningOf<T extends AnyConstructor> {
    (original: T, seen: WeakMap<any, any>): T;
}
export declare const cloneHandlers: Map<AnyConstructor, HandleCloningOf<any>>;
export interface HandleEquatingOf {
    (a: unknown, b: unknown, seen?: WeakMap<WeakKey, WeakKey>): boolean;
}
export interface HandleMergeOf<T = unknown, U = unknown> {
    (a: T, b: U, opts?: MergeOptions): T & U;
}
export declare const mergeHandlers: Map<AnyConstructor, HandleMergeOf>;
export declare const equalityHandlers: Map<AnyConstructor, HandleEquatingOf>;
/**
 * Checks if a property key is dangerous for prototype pollution
 *
 * @param key - The property key to check
 * @returns true if the key is dangerous and should be skipped
 *
 * @example
 * isDangerousKey('__proto__'); // true
 * isDangerousKey('constructor'); // true
 * isDangerousKey('normalProp'); // false
 */
export declare const isDangerousKey: (key: string | symbol | number) => boolean;
/**
 * Filters out dangerous properties from an object's keys to prevent prototype pollution
 *
 * @param obj - The object to get safe keys from
 * @returns Array of safe property keys
 *
 * @example
 * const obj = { a: 1, __proto__: {}, constructor: Function };
 * getSafeKeys(obj); // ['a']
 */
export declare const getSafeKeys: <T extends object>(obj: T) => (keyof T)[];
/**
 * Filters out dangerous properties when iterating over object entries
 *
 * @param obj - The object to get safe entries from
 * @returns Array of safe [key, value] pairs
 *
 * @example
 * const obj = { a: 1, __proto__: {}, b: 2 };
 * getSafeEntries(obj); // [['a', 1], ['b', 2]]
 */
export declare const getSafeEntries: <T extends object>(obj: T) => Array<[keyof T, T[keyof T]]>;
/**
 * Helper type to detect if a type is a primitive value
 */
type IsPrimitive<T> = T extends string | number | boolean | symbol | null | undefined | bigint ? true : false;
/**
 * Helper type to detect if a type is an array
 */
type IsArray<T> = T extends Array<any> ? true : false;
/**
 * Helper type to detect if a type is a Map
 */
type IsMap<T> = T extends Map<any, any> ? true : false;
/**
 * Helper type to detect if a type is a Set
 */
type IsSet<T> = T extends Set<any> ? true : false;
/**
 * Helper type to detect if a type is a special collection (Array, Map, Set)
 */
type IsSpecialCollection<T> = IsArray<T> extends true ? true : IsMap<T> extends true ? true : IsSet<T> extends true ? true : false;
/**
 * Helper type to merge two array types
 */
type MergeArrays<Target, Source> = Target extends Array<infer TargetItem> ? Source extends Array<infer SourceItem> ? Array<TargetItem | SourceItem> : Source : Source;
/**
 * Helper type to merge two Map types
 */
type MergeMaps<Target, Source> = Target extends Map<infer TK, infer TV> ? Source extends Map<infer SK, infer SV> ? Map<TK | SK, TV | SV> : Source : Source;
/**
 * Helper type to merge two Set types
 */
type MergeSets<Target, Source> = Target extends Set<infer TargetItem> ? Source extends Set<infer SourceItem> ? Set<TargetItem | SourceItem> : Source : Source;
/**
 * Helper type to merge special collections (Arrays, Maps, Sets)
 */
type MergeSpecialCollections<Target, Source> = IsArray<Target> extends true ? MergeArrays<Target, Source> : IsMap<Target> extends true ? MergeMaps<Target, Source> : IsSet<Target> extends true ? MergeSets<Target, Source> : Source;
/**
 * Helper type to merge two property values based on their types
 */
type MergePropertyValues<Target, Source> = IsPrimitive<Source> extends true ? Source : IsSpecialCollection<Target> extends true ? MergeSpecialCollections<Target, Source> : IsSpecialCollection<Source> extends true ? Source : Target extends object ? Source extends object ? MergeTypes<Target, Source> : Source : Source;
/**
 * Smart merge type that properly handles nested object merging with support for Arrays, Maps, and Sets
 *
 * @example
 * type Result = MergeTypes<
 *   { a: number; nested: { x: string } },
 *   { b: string; nested: { y: number } }
 * >;
 * // Result: { a: number; b: string; nested: { x: string; y: number } }
 */
export type MergeTypes<Target, Source> = {
    [K in keyof Target | keyof Source]: K extends keyof Source ? K extends keyof Target ? MergePropertyValues<Target[K], Source[K]> : Source[K] : K extends keyof Target ? Target[K] : never;
};
type AddHandleForClone<T extends AnyConstructor> = (target: InstanceType<T>, seen?: WeakMap<any, any>) => InstanceType<T>;
type AddHandlerForMerge<T extends AnyConstructor> = (target: InstanceType<T>, source: InstanceType<T>, opts?: MergeOptions) => InstanceType<T>;
type AddHandlerForEquals<T extends AnyConstructor> = (target: InstanceType<T>, source: InstanceType<T>) => boolean;
interface AddHandlerFor {
    <T extends AnyConstructor>(fn: 'clone', cnstr: T, handler: AddHandleForClone<T>): void;
    <T extends AnyConstructor>(fn: 'merge', cnstr: T, handler: AddHandlerForMerge<T>): void;
    <T extends AnyConstructor>(fn: 'equals', cnstr: T, handler: AddHandlerForEquals<T>): void;
}
/**
 * Add a handler for a specific function
 * @param fn - the function to add the handler for
 * @param cnstr - the constructor to add the handler for
 * @param handler - the handler to add

* @example
 * addHandlerFor('clone', FooClass, (original, seen) => new FooClass(original.bar, original.baz));
 * addHandlerFor('equals', FooClass, (a, b, seen) => equals(a.bar, b.bar, seen) && equals(a.baz, b.baz, seen));
 * addHandlerFor('merge', FooClass, (target, source, opts) => merge(target.bar, source.bar, opts));
 */
export declare const addHandlerFor: AddHandlerFor;
export {};