/**
 * Creates a new object composed of the picked object properties.
 *
 * This function takes an object and an array of keys, and returns a new object that
 * includes only the properties corresponding to the specified keys.
 * @template T - The type of object.
 * @template K - The type of keys in object.
 * @param {T} obj - The object to pick keys from.
 * @param {K[]} keys - An array of keys to be picked from the object.
 * @returns {Pick<T, K>} A new object with the specified keys picked.
 * @example
 * const obj = { a: 1, b: 2, c: 3 };
 * const result = pick(obj, ['a', 'c']);
 * // result will be { a: 1, c: 3 }
 */
export declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: readonly K[]): Pick<T, K>;
type DeepPartial<T> = {
    [K in keyof T]?: T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K];
};
/**
 * Recursively merges properties of source objects into the target object.
 * Plain object values are merged recursively; all other values (arrays, primitives, class instances)
 * are replaced by the source value. Source `undefined` values do not overwrite target values.
 */
export declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: DeepPartial<T>[]): T;
/**
 * Creates a new object omitting properties for which the predicate returns true.
 * @example
 * omitBy({ a: '', b: 'hello', c: '' }, v => v === '')
 * // => { b: 'hello' }
 */
export declare function omitBy<T extends Record<string, unknown>>(obj: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
export {};