/**
 * Determines whether the argument is a plain instance of Object.
 *
 * @param value The value to check.
 */
export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
/**
 * Similar to Array.map, except that it maps over an object's own enumerable
 * properties.
 *
 * @param obj The object to map over.
 * @param callback The callback to invoke for each property. The callback's
 *   return value will be used as the new value for the given property in the
 *   returned object.
 * @returns An object containing the new values produced by the callback
 *   function.
 */
export declare function map<T extends object, K extends keyof T, V>(obj: T, callback: (value: T[K], key: K, obj: T) => V): {
    [K in keyof T]: V;
};
/**
 * Similar to Array.filter, except that it filters an object's own enumerable
 * properties.
 *
 * @param obj The object to filter.
 * @param callback The callback to invoke for each property. The callback's
 *   return value will determine whether the property is kept in the result.
 * @returns An object containing the properties for which the callback function
 *   returned a value that evaluates to `true`.
 */
export declare function filter<T extends Record<string, unknown>>(obj: T, callback: (value: T[keyof T], key: keyof T, obj: T) => boolean): Partial<T>;
/**
 * Like Object.keys, but unsound in exchange for more convenience.
 *
 * Casts the result of Object.keys to the known keys of an object type, even
 * though JavaScript objects may contain additional keys.
 *
 * Only use this function when you know/control the provenance of the object
 * you're iterating, and can verify it contains exactly the keys declared to the
 * type system.
 *
 * Example:
 *
 *     const o = {x: "ok", y: 10}
 *     o["z"] = "UNTRACKED_KEY"
 *     const safeKeys = Object.keys(o)
 *     const unsafeKeys = objectKeys(o)
 *     ```.
 */
export declare const objectKeys: <T>(obj: T) => (keyof T)[];
/**
 * The type of a single item in `Object.entries<T>(value: T)`.
 */
export type ObjectEntry<T> = {
    [K in Exclude<keyof T, undefined>]: [K, T[K]];
}[Exclude<keyof T, undefined>];
/**
 * Like Object.entries, but returns a more specific type which can be less safe.
 *
 * See `ObjectEntry` above.
 *
 * Note that Object.entries collapses all possible values into a single union
 * while objectEntries results in a union of 2-tuples.
 */
export declare const objectEntries: <T>(o: T) => ObjectEntry<T>[];
/**
 * Copies property values from one or more source objects to a target object.
 * Same as the ES2015 Object.assign method, with the following differences:
 *
 * - Performs the copying recursively.
 * - Silently skips target properties that are not writable, instead of throwing
 *   an error.
 * - Whenever any object in the target object graph has a method named
 *   "assignProperties", deepAssign() will invoke this method with the source
 *   data to copy instead of performing its normal copying behavior.
 *
 * @param target The target object to copy properties to.
 * @param source The source object to copy properties from.
 * @returns The target object.
 */
export declare function deepAssign<T, U>(target: T, source: U): T & U;
/**
 * Copies property values from one or more source objects to a target object.
 * Same as the ES2015 Object.assign method, with the following differences:
 *
 * - Performs the copying recursively.
 * - Silently skips target properties that are not writable, instead of throwing
 *   an error.
 * - Whenever any object in the target object graph has a method named
 *   "assignProperties", deepAssign() will invoke this method with the source
 *   data to copy instead of performing its normal copying behavior.
 *
 * @param target The target object to copy properties to.
 * @param source1 The first source object to copy properties from.
 * @param source2 The second source object to copy properties from.
 * @returns The target object.
 */
export declare function deepAssign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
/**
 * Copies property values from one or more source objects to a target object.
 * Same as the ES2015 Object.assign method, with the following differences:
 *
 * - Performs the copying recursively.
 * - Silently skips target properties that are not writable, instead of throwing
 *   an error.
 * - Whenever any object in the target object graph has a method named
 *   "assignProperties", deepAssign() will invoke this method with the source
 *   data to copy instead of performing its normal copying behavior.
 *
 * @param target The target object to copy properties to.
 * @param source1 The first source object to copy properties from.
 * @param source2 The second source object to copy properties from.
 * @param source3 The third source object to copy properties from.
 * @returns The target object.
 */
export declare function deepAssign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
/**
 * Returns true if the object has no direct properties, false otherwise.
 *
 * @param obj The object to check.
 */
export declare function isEmpty<T extends object = object>(obj: T): boolean;
/**
 * Converts a value to its serializable representation (plain JSON).
 *
 * @param value The value to convert.
 */
export declare function toJSON<T extends object | number = object>(value: T | null | undefined): unknown;
/**
 * Clone the object properties as well as any descendant objects.
 *
 * @param obj The object to clone.
 * @returns A deep cloned object.
 */
export declare function deepClone<T>(obj: T): T;
/**
 * Similar to Object.getOwnPropertyDescriptor, without the "own" part.
 *
 * @param obj The object in which to look for the property.
 * @param property The name of the property whose description is to be
 *   retrieved.
 */
export declare function getPropertyDescriptor<T = unknown>(obj: T, property: string | symbol | number): PropertyDescriptor | undefined;
/**
 * Traverses the entirety of an object, searching for property names that match
 * the provided propName and transforming their values with the provided
 * callback. Returns true if a property is found and transformed.
 *
 * @param propName The string or RegExp that is used to match property names
 *   throughout the given object.
 * @param object The object that will be searched within.
 * @param transformer The callback used to alter the values of found properties.
 *   The transformer will receive the current value of the property and should
 *   return the new value.
 * @param ignoreTransformedValues Do not deep search and transform values
 *   created by the transformer. Defaults to true.
 */
export declare function deepSearchAndTransform<T extends object = object>(propName: string | RegExp, object: T, transformer: (prop: unknown) => unknown, ignoreTransformedValues?: boolean): boolean;
/**
 * Traverses the entirety of an object, searching for property names that match
 * the provided propName and transforming their values with the provided
 * callback. Returns true if a property is found and transformed.
 *
 * @param propName The string or RegExp that is used to match property names
 *   throughout the given object.
 * @param object The object that will be searched within.
 * @param transformer The callback used to alter the values of found properties.
 *   The transformer will receive the current value of the property and should
 *   return the new value.
 * @param ignoreTransformedValues Do not deep search and transform values
 *   created by the transformer. Defaults to true.
 */
export declare function deepSearchAndTransformAsync<T extends object = object>(propName: string | RegExp, object: T, transformer: (prop: unknown) => Promise<unknown>, ignoreTransformedValues?: boolean): Promise<boolean>;
