import { type Types } from './Types';
export declare namespace Objects {
    function isNotNullOrUndefined<T>(arg: T | null | undefined): arg is NonNullable<T>;
    function isNullOrUndefined<T>(arg: T | null | undefined): arg is null | undefined;
    function isObject<T = {}>(arg: unknown | T): arg is Record<keyof T, T[keyof T]>;
    function isFunction(arg: unknown): arg is Function;
    function isArray<T>(arg: unknown): arg is T[];
    function isString(arg: unknown): arg is string;
    function isNumeric(arg: unknown): arg is number;
    function isBoolean(arg: unknown): arg is boolean;
    function isPrimitive(arg: unknown): arg is Types.Primitive;
    function forEach<T extends {}>(obj: T, callback: (key: keyof T, value: T[keyof T]) => void): void;
    function isConstructorOf<T>(test: unknown, targetClass: Types.Newable<T>): test is Types.Newable<T>;
    function equals<T1, T2>(obj1?: T1, obj2?: T2): boolean;
    function keys<T extends Record<PropertyKey, unknown>>(obj: T): ReadonlyArray<keyof T>;
    function assign<T extends {}>(target: T, source: Partial<T>): T;
    function deepCopy<T>(obj: Types.SerializableObject<T>): T;
    function deepCopy<T>(obj: T, transferNotCopyable: true): T;
    function extend<DST extends {}, SRC extends {}>(dst: DST, src: SRC, options?: {
        canOverwrite?: <DST extends {}, SRC extends {}>(dst: DST, src: SRC, key: keyof SRC) => boolean;
    }): boolean;
    function isCharacterWhitespace(c: string): boolean;
    function isBlankString(str: string): boolean;
    function visit<OBJ extends {}>(obj: OBJ, visitor: (obj: OBJ, level: number) => OBJ[] | void): void;
    function flatten<OBJ extends {}>(obj: OBJ, childrenExtractor: (obj: OBJ, level: number) => OBJ[] | void): OBJ[];
    function setPrototypeOf<P extends object, T>(target: T, proto: P): T & P;
    function deepFreeze<T>(obj: T): Types.DeepReadonly<T>;
    function getKeyByValue<E extends Record<PropertyKey, unknown>, V extends E[keyof E]>(enumObj: E, enumValue: V): Types.KeyForValue<E, V>;
    function transform<T extends {}, R = Record<PropertyKey, unknown>>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => [key: keyof R, value: R[keyof R]] | undefined): R;
    function difference<T extends {}, B extends {}>(object: T, base: B): Partial<T>;
}