/**
 * Converts a union type to an intersection type.
 *
 * This utility type is used internally to represent the result of merging multiple
 * object types into a single type containing all their properties.
 *
 * Example:
 * ```ts
 * type A = { a: number };
 * type B = { b: string };
 * type C = TUnionToIntersection<A | B>; // { a: number } & { b: string }
 * ```
 */
type TUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
/**
 * Deeply merges multiple plain objects into a single object.
 *
 * For each property:
 * - If both source and target properties are plain objects, they are merged recursively.
 * - If both are arrays, the source array overwrites the target array.
 * - Otherwise, the source property overwrites the target property.
 *
 * This function skips dangerous keys like `__proto__`, `constructor`, and `prototype`
 * to prevent prototype pollution.
 *
 * @param objects - Two or more plain objects to merge.
 * @returns A new object that is the deep merge of all input objects.
 *
 * @example
 * ```ts
 * const a = { x: 1, nested: { y: 2 } };
 * const b = { nested: { z: 3 }, arr: [1, 2] };
 * const merged = deepMerge(a, b);
 * // { x: 1, nested: { y: 2, z: 3 }, arr: [1, 2] }
 * ```
 */
export declare function deepMerge<T extends object[]>(...objects: T): TUnionToIntersection<T[number]>;
export {};
//# sourceMappingURL=deep-merge.d.ts.map