/**
 * Extract key-value pairs common to all input objects.
 *
 * A key-value pair is considered common when the key exists in every object
 * and the value is strictly equal (===) across all objects.
 * When all values for a key are plain objects, the function recurses to find
 * the common subset. If the recursive result is empty, the key is excluded.
 *
 * @template T - Type of the input objects.
 * @param {T} object - The first object.
 * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
 * @returns {Partial<T>} Object containing only the key-value pairs shared by all inputs.
 *
 * @remarks
 * **Prototype pollution warning:** This function does not filter out
 * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
 * If processing user-controlled input, sanitize with the appropriate
 * `removePrototype*` helper before calling this function:
 * - `removePrototype` — shallow sanitization of a single object
 * - `removePrototypeDeep` — recursive sanitization of a single object (for deeply nested data)
 * - `removePrototypeMap` — shallow sanitization of an array of objects
 * - `removePrototypeMapDeep` — recursive sanitization of an array of objects (for deeply nested data)
 *
 * @example
 * ```typescript
 * getObjectsCommon({ a: 1, b: 2 }, { a: 1, c: 3 });
 * // { a: 1 }
 *
 * getObjectsCommon({ a: { b: 1, c: 2 }, d: 3 }, { a: { b: 1, d: 4 }, d: 3 });
 * // { a: { b: 1 }, d: 3 }
 * ```
 */
export declare const getObjectsCommon: <T extends Record<string, unknown>>(object: T, ...objects: Record<string, unknown>[]) => Partial<T>;