import type { DeepPartial, DeepReadonly, DeepRequired } from 'ts-essentials';
/**
 * checks if `item` is an object (it may be an array, ...)
 */
export declare function isObjectOrArray(item: unknown): boolean;
export type MergeableRecord = Record<string, unknown>;
export type MergeableArray = unknown[];
export type Mergeable = MergeableRecord | MergeableArray;
type OrReadonly<T> = T | Readonly<T> | DeepReadonly<T>;
/**
 * Given two objects deeply merges them, if an object is an array it will merge the array values!
 * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
 */
export declare function deepMergeObject<T extends Mergeable>(base: Required<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): Required<T>;
export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): DeepRequired<T>;
export declare function deepMergeObject<T extends Mergeable>(base: OrReadonly<T>, addon?: DeepPartial<T> | Partial<T>): T;
export declare function deepMergeObject(base: Mergeable, addon: Mergeable): Mergeable;
export declare function deepMergeObject(base?: Mergeable, addon?: Mergeable): Mergeable | undefined;
type Defined<T> = Exclude<T, undefined>;
type DefinedRecord<T> = {
    [K in keyof T as T[K] extends undefined ? never : K]: Defined<T[K]>;
};
export declare function compactRecord<T extends Record<string, unknown>>(record: T): DefinedRecord<T>;
export declare function compactRecord(record: undefined): undefined;
export declare function compactRecord<T extends Record<string, unknown>>(record: T | undefined): DefinedRecord<T> | undefined;
export {};