import type { Frozen, Key, StringRecord, ValuePathToObject } from '@toolbox-ts/types/defs/object';
/**
 * Checks if a value is of any `object` type (including functions), with an option to allow `null`.
 * - Excludes null by default, but can be included by setting `allowNull` to `true`.
 */
export declare const isObjectAny: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<object, [allowNull?: boolean | undefined]>, "ObjectAny">;
/**
 * Checks if a value is of any `object` type (including functions), with an option to allow `null`.
 * - Excludes null by default, but can be included by setting `allowNull` to `true`.
 */
export declare const checkIsObjectAny: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[allowNull?: boolean | undefined]>, "ObjectAny">;
/**
 * Asserts if a value is of any `object` type (including functions), with an option to allow `null`.
 * - Excludes null by default, but can be included by setting `allowNull` to `true`.
 */
export declare function assertIsObjectAny(v: unknown, allowNull?: boolean): asserts v is object;
export declare const isObject: {
    readonly name: "isObject";
    readonly typeName: "Object";
} & (<T>(v: T) => v is StringRecord & T);
export declare const checkIsObject: {
    readonly name: "checkIsObject";
    readonly typeName: "Object";
} & ((v: unknown) => boolean);
export declare function assertIsObject<T>(v: T): asserts v is StringRecord & T;
export declare const isObjectNotPlain: {
    readonly name: "isObjectNotPlain";
    readonly typeName: "ObjectNotPlain";
} & (<T>(v: T) => v is T & object);
export declare const checkIsObjectNotPlain: {
    readonly name: "checkIsObjectNotPlain";
    readonly typeName: "ObjectNotPlain";
} & ((v: unknown) => boolean);
export declare function assertIsObjectNotPlain<T>(v: T): asserts v is T & object;
export declare const isObjectEmpty: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Record<string, never>, []>, "ObjectEmpty">;
export declare const checkIsObjectEmpty: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "ObjectEmpty">;
export declare function assertIsObjectEmpty(v: unknown): asserts v is Record<string, never>;
export declare const isNotObjectEmpty: {
    readonly name: "isObjectNotEmpty";
    readonly typeName: "ObjectNotEmpty";
} & (<T>(v: T) => v is {
    [key: string]: unknown;
} & T);
export declare const checkIsNotObjectEmpty: {
    readonly name: "checkIsObjectNotEmpty";
    readonly typeName: "ObjectNotEmpty";
} & ((v: unknown) => boolean);
export declare function assertIsNotObjectEmpty<T>(v: T): asserts v is StringRecord & T;
export declare const isObjectWithKeys: {
    readonly name: "isObjectWithKeys";
    readonly typeName: "ObjectWithKeys";
} & (<K extends string, T = object>(v: T, keys: readonly K[]) => v is { [Y in K]: unknown; } & T);
export declare const checkIsObjectWithKeys: {
    readonly name: "checkIsObjectWithKeys";
    readonly typeName: "ObjectWithKeys";
} & ((v: unknown, keys: readonly string[]) => boolean);
export declare function assertIsObjectWithKeys<K extends string, T = object>(v: T, keys: readonly K[]): asserts v is {
    [Y in K]: unknown;
} & T;
export declare const isObjectWithValues: {
    readonly name: "isObjectWithValues";
    readonly typeName: "ObjectWithValues";
} & (<T>(v: unknown, valueGuard: (value: unknown) => value is T) => v is StringRecord<T>);
export declare const checkIsObjectWithValues: {
    readonly name: "checkIsObjectWithValues";
    readonly typeName: "ObjectWithValues";
} & ((v: unknown, valueGuard: (value: unknown) => value is unknown) => boolean);
export declare function assertIsObjectWithValues<T>(v: unknown, valueGuard: (value: unknown) => value is T, expectedTypeName?: string): asserts v is Record<string, T>;
export declare const isObjectWithEntry: {
    readonly name: "isObjectWithEntry";
    readonly typeName: "ObjectWithEntry";
} & (<K extends string, V = unknown, T = object>(obj: unknown, key: K, valueGuard?: (value: unknown) => value is V) => obj is ValuePathToObject<K, V> & T);
export declare const checkIsObjectWithEntry: {
    readonly name: "checkIsObjectWithEntry";
    readonly typeName: "ObjectWithEntry";
} & ((v: unknown, key: string, valueGuard?: ((value: unknown) => value is unknown) | undefined) => boolean);
export declare const assertIsObjectWithEntry: <K extends string, V = unknown, T = object>(v: unknown, key: K, valueGuard?: (value: unknown) => value is T) => asserts v is ValuePathToObject<K, V> & T;
export declare const isObjectProxy: {
    readonly name: "isObjectProxy";
    readonly typeName: "ObjectProxy";
} & (<T extends object = object>(v: T) => v is InstanceType<typeof Proxy> & T);
export declare const checkIsObjectProxy: never;
export declare function assertIsObjectProxy<T extends object = object>(v: T): asserts v is InstanceType<typeof Proxy> & T;
export declare const isObjectIterable: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Iterable<unknown>, []>, "ObjectIterable">;
export declare const checkIsObjectIterable: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "ObjectIterable">;
export declare function assertIsObjectIterable<T = unknown>(v: unknown): asserts v is Iterable<T>;
export declare const isObjectPrototypeKey: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Key.Prototype, []>, "ObjectPrototypeKey">;
export declare const checkIsObjectPrototypeKey: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "ObjectPrototypeKey">;
export declare function assertIsObjectPrototypeKey(v: unknown): asserts v is Key.Prototype;
export declare const isObjectFrozen: {
    readonly name: "isObjectFrozen";
    readonly typeName: "ObjectFrozen";
} & (<T>(v: T) => v is Frozen<T>);
export declare const checkIsObjectFrozen: {
    readonly name: "checkIsObjectFrozen";
    readonly typeName: "ObjectFrozen";
} & ((v: unknown) => boolean);
export declare function assertIsObjectFrozen<T>(v: T): asserts v is Frozen<T>;
export declare const isObjectExtensible: {
    readonly name: "isObjectExtensible";
    readonly typeName: "ObjectExtensible";
} & (<T>(v: T) => v is object & T);
export declare const checkIsObjectExtensible: {
    readonly name: "checkIsObjectExtensible";
    readonly typeName: "ObjectExtensible";
} & ((v: unknown) => boolean);
export declare function assertIsObjectExtensible<T>(v: T): asserts v is object & T;
export declare const isObjectSealed: {
    readonly name: "isObjectSealed";
    readonly typeName: "ObjectSealed";
} & (<T>(v: T) => v is object & T);
export declare const checkIsObjectSealed: {
    readonly name: "checkIsObjectSealed";
    readonly typeName: "ObjectSealed";
} & ((v: unknown) => boolean);
export declare function assertIsObjectSealed<T>(v: T): asserts v is object & T;