import type { PropertyPath } from "../types.js";
/**
 * Enhanced deep pick that picks properties from nested objects.
 * This is an advanced utility beyond standard Lodash.
 *
 * @param object - The source object
 * @param paths - The property paths to pick (supports dot notation)
 * @returns Returns the new object
 *
 * @example
 * const object = {
 *   a: { b: { c: 1 } },
 *   d: { e: 2 },
 *   f: 3
 * };
 *
 * deepPick(object, ['a.b.c', 'f']);
 * // => { a: { b: { c: 1 } }, f: 3 }
 */
export declare function deepPick<T extends Record<string, any>>(object: T, paths: readonly PropertyPath[]): Partial<T>;
/**
 * Enhanced deep omit that omits properties from nested objects.
 * This is an advanced utility beyond standard Lodash.
 *
 * @param object - The source object
 * @param paths - The property paths to omit (supports dot notation)
 * @returns Returns the new object
 *
 * @example
 * const object = {
 *   a: { b: { c: 1, d: 2 } },
 *   e: { f: 3 },
 *   g: 4
 * };
 *
 * deepOmit(object, ['a.b.c', 'g']);
 * // => { a: { b: { d: 2 } }, e: { f: 3 } }
 */
export declare function deepOmit<T extends Record<string, any>>(object: T, paths: readonly PropertyPath[]): Partial<T>;
/**
 * Transform object keys recursively using a transformation function.
 * This is an advanced utility beyond standard Lodash.
 *
 * @param object - The object to transform
 * @param transformer - Function to transform each key
 * @returns Returns the object with transformed keys
 *
 * @example
 * const object = {
 *   firstName: 'John',
 *   lastName: 'Doe',
 *   address: { streetName: '123 Main St', zipCode: '12345' }
 * };
 *
 * // Convert camelCase to snake_case
 * transformKeys(object, key =>
 *   key.replace(/([A-Z])/g, '_$1').toLowerCase()
 * );
 * // => {
 * //   first_name: 'John',
 * //   last_name: 'Doe',
 * //   address: { street_name: '123 Main St', zip_code: '12345' }
 * // }
 */
export declare function transformKeys<T>(object: T, transformer: (key: string) => string): any;
/**
 * This method is like `assign` except that it recursively merges own and
 * inherited enumerable string keyed properties of source objects into the
 * destination object.
 *
 * @param object - The destination object
 * @param sources - The source objects
 * @returns Returns object
 *
 * @example
 * const object = {
 *   'a': [{ 'b': 2 }, { 'd': 4 }]
 * };
 *
 * const other = {
 *   'a': [{ 'c': 3 }, { 'e': 5 }]
 * };
 *
 * mergeDeep(object, other);
 * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
 */
export declare function mergeDeep<T extends Record<string, any>>(object: T, ...sources: Array<Partial<T>>): T;
/**
 * This method is like `mergeDeep` except that it accepts `customizer` which
 * is invoked to produce the merged values of the destination and source
 * properties.
 *
 * @param object - The destination object
 * @param sources - The source objects
 * @param customizer - The function to customize assigned values
 * @returns Returns object
 */
export declare function mergeWith<T extends Record<string, any>>(object: T, ...args: [
    ...sources: Array<Partial<T>>,
    customizer: (objValue: any, srcValue: any, key: string, object: any, source: any) => any
]): T;
/**
 * Creates an object composed of keys generated from the results of running
 * each element of collection thru iteratee.
 *
 * @param collection - The collection to iterate over
 * @param iteratee - The iteratee to transform keys
 * @returns Returns the composed aggregate object
 *
 * @example
 * keyBy(['a', 'b', 'c'], (value, index) => index);
 * // => { '0': 'a', '1': 'b', '2': 'c' }
 */
export declare function keyBy<T>(collection: readonly T[], iteratee: (value: T, index: number) => string): Record<string, T>;