import type { Frozen } from '@toolbox-ts/types/defs/object';
import { assertIsObject, assertIsObjectEmpty, assertIsNotObjectEmpty, assertIsObjectExtensible, assertIsObjectAny, assertIsObjectNotPlain, assertIsObjectFrozen, assertIsObjectIterable, assertIsObjectPrototypeKey, assertIsObjectProxy, assertIsObjectWithKeys, assertIsObjectWithValues, assertIsObjectSealed } from '../../../core/guards/objs/base/index.js';
import { assertIsMapWithEntries, assertIsMapWithKeys, assertIsMapWithValues } from '../../../core/guards/objs/map/index.js';
import { assertIsSetOf } from '../../../core/guards/objs/set/index.js';
export declare const is: {
    /** @narrows `object` */
    readonly any: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<object, [allowNull?: boolean | undefined]>, "ObjectAny">;
    /** @narrows `T & object` */
    readonly notPlain: {
        readonly name: "isObjectNotPlain";
        readonly typeName: "ObjectNotPlain";
    } & (<T>(v: T) => v is T & object);
    /** @narrows `T & Record\<string, unknown\>` */
    readonly notEmpty: {
        readonly name: "isObjectNotEmpty";
        readonly typeName: "ObjectNotEmpty";
    } & (<T>(v: T) => v is {
        [key: string]: unknown;
    } & T);
    /** @narrows `Record\<string, never\>` */
    readonly empty: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Record<string, never>, []>, "ObjectEmpty">;
    /** @narrows `Iterable<T>` */
    readonly iterable: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<Iterable<unknown>, []>, "ObjectIterable">;
    /** @narrows `'__proto__' | 'constructor' | 'prototype'` */
    readonly prototypeKey: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").IsGuard<import("@toolbox-ts/types/defs/object").KeyPrototype, []>, "ObjectPrototypeKey">;
    /** @narrows `T & InstanceType\<typeof Proxy\>` */
    readonly proxy: {
        readonly name: "isObjectProxy";
        readonly typeName: "ObjectProxy";
    } & (<T extends object = object>(v: T) => v is InstanceType<typeof Proxy> & T);
    /** @narrows `T & T.Key0.Key1...KeyN: V */
    readonly withEntry: {
        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 import("@toolbox-ts/types/defs/object").ValuePathToObject<K, V> & T);
    /** @narrows `T & \{ [K in Keys]: unknown \}` */
    readonly withKeys: {
        readonly name: "isObjectWithKeys";
        readonly typeName: "ObjectWithKeys";
    } & (<K extends string, T = object>(v: T, keys: readonly K[]) => v is { [Y in K]: unknown; } & T);
    /** @narrows `Record\<string, V\>` */
    readonly withValues: {
        readonly name: "isObjectWithValues";
        readonly typeName: "ObjectWithValues";
    } & (<T>(v: unknown, valueGuard: (value: unknown) => value is T) => v is import("@toolbox-ts/types/defs/object").StringRecord<T>);
    /** @narrows `T & object` */
    readonly extensible: {
        readonly name: "isObjectExtensible";
        readonly typeName: "ObjectExtensible";
    } & (<T>(v: T) => v is object & T);
    /** @narrows {@link Frozen} */
    readonly frozen: {
        readonly name: "isObjectFrozen";
        readonly typeName: "ObjectFrozen";
    } & (<T>(v: T) => v is Frozen<T>);
    /** @narrows `T & object` */
    readonly sealed: {
        readonly name: "isObjectSealed";
        readonly typeName: "ObjectSealed";
    } & (<T>(v: T) => v is object & T);
    /** @narrows `T & Record\<K, unknown\>` */
    readonly plain: {
        readonly name: "isObject";
        readonly typeName: "Object";
    } & (<T>(v: T) => v is import("@toolbox-ts/types/defs/object").StringRecord & T);
    /** @narrows `Map\<K, V\>` */
    readonly mapWithEntries: {
        readonly name: "isMapWithEntries";
        readonly typeName: "MapWithEntries";
    } & (<T extends Record<string, (x: unknown) => x is unknown>>(v: unknown, validators: T) => v is Map<keyof T & string, T[keyof T & string] extends ((x: unknown) => x is infer U) ? U : never>);
    /** @narrows `Map\<K, unknown\>` */
    readonly mapWithKeys: {
        readonly name: "isMapWithKeys";
        readonly typeName: "MapWithKeys";
    } & (<K extends string>(v: unknown, keys: readonly K[]) => v is Map<K, unknown>);
    /** @narrows `Map\<unknown, V\>` */
    readonly mapWithValues: {
        readonly name: "isMapWithValues";
        readonly typeName: "MapWithValues";
    } & (<V>(v: unknown, valueGuard: (x: unknown) => x is V) => v is Map<unknown, V>);
    /** @narrows `Set<T>` */
    readonly setOf: {
        readonly name: "isSetOf";
        readonly typeName: "SetOf";
    } & (<V>(v: unknown, valueValidator: (val: unknown) => val is V) => v is Set<V>);
};
export declare const assert: {
    /** @asserts `object` */
    any: typeof assertIsObjectAny;
    /** @asserts `T & object` */
    notPlain: typeof assertIsObjectNotPlain;
    /** @asserts `T & Record\<string, unknown\>` */
    notEmpty: typeof assertIsNotObjectEmpty;
    /** @asserts `Record\<string, never\>` */
    empty: typeof assertIsObjectEmpty;
    /** @asserts `Iterable<T>` */
    iterable: typeof assertIsObjectIterable;
    /** @asserts `'__proto__' | 'constructor' | 'prototype'` */
    prototypeKey: typeof assertIsObjectPrototypeKey;
    /** @asserts `T & InstanceType\<typeof Proxy\>` */
    proxy: typeof assertIsObjectProxy;
    /** @asserts `T & T.Key0.Key1...KeyN: V */
    withEntry: <K extends string, V = unknown, T = object>(v: unknown, key: K, valueGuard?: (value: unknown) => value is T) => asserts v is import("@toolbox-ts/types/defs/object").ValuePathToObject<K, V> & T;
    /** @asserts `T & \{ [K in Keys]: unknown \}` */
    withKeys: typeof assertIsObjectWithKeys;
    /** @asserts `Record\<string, V\>` */
    withValues: typeof assertIsObjectWithValues;
    /** @asserts `T & object` */
    extensible: typeof assertIsObjectExtensible;
    /** @asserts {@link Frozen} */
    frozen: typeof assertIsObjectFrozen;
    /** @asserts `T & object` */
    sealed: typeof assertIsObjectSealed;
    /** @asserts `T & Record\<K, unknown\>` */
    plain: typeof assertIsObject;
    /** @asserts `Map\<K, V\>` */
    mapWithEntries: typeof assertIsMapWithEntries;
    /** @asserts `Map\<K, unknown\>` */
    mapWithKeys: typeof assertIsMapWithKeys;
    /** @asserts `Map\<unknown, V\>` */
    mapWithValues: typeof assertIsMapWithValues;
    /** @asserts `Set<T>` */
    setOf: typeof assertIsSetOf;
};
export declare const check: {
    /** @checks `object` */
    readonly any: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[allowNull?: boolean | undefined]>, "ObjectAny">;
    /** @checks `T & object` */
    readonly notPlain: {
        readonly name: "checkIsObjectNotPlain";
        readonly typeName: "ObjectNotPlain";
    } & ((v: unknown) => boolean);
    /** @checks `T & Record\<string, unknown\>` */
    readonly notEmpty: {
        readonly name: "checkIsObjectNotEmpty";
        readonly typeName: "ObjectNotEmpty";
    } & ((v: unknown) => boolean);
    /** @checks `Record\<string, never\>` */
    readonly empty: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "ObjectEmpty">;
    /** @checks `Iterable<T>` */
    readonly iterable: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "ObjectIterable">;
    /** @checks `'__proto__' | 'constructor' | 'prototype'` */
    readonly prototypeKey: import("@toolbox-ts/types/defs/function").TypeGuard<import("@toolbox-ts/types/defs/function").CheckGuard<[]>, "ObjectPrototypeKey">;
    /** @checks `T & InstanceType\<typeof Proxy\>` */
    readonly proxy: never;
    /** @checks `T & T.Key0.Key1...KeyN: V */
    readonly withEntry: {
        readonly name: "checkIsObjectWithEntry";
        readonly typeName: "ObjectWithEntry";
    } & ((v: unknown, key: string, valueGuard?: ((value: unknown) => value is unknown) | undefined) => boolean);
    /** @checks `T & \{ [K in Keys]: unknown \}` */
    readonly withKeys: {
        readonly name: "checkIsObjectWithKeys";
        readonly typeName: "ObjectWithKeys";
    } & ((v: unknown, keys: readonly string[]) => boolean);
    /** @checks `Record\<string, V\>` */
    readonly withValues: {
        readonly name: "checkIsObjectWithValues";
        readonly typeName: "ObjectWithValues";
    } & ((v: unknown, valueGuard: (value: unknown) => value is unknown) => boolean);
    /** @checks `T & object` */
    readonly extensible: {
        readonly name: "checkIsObjectExtensible";
        readonly typeName: "ObjectExtensible";
    } & ((v: unknown) => boolean);
    /** @checks {@link Frozen} */
    readonly frozen: {
        readonly name: "checkIsObjectFrozen";
        readonly typeName: "ObjectFrozen";
    } & ((v: unknown) => boolean);
    /** @checks `T & object` */
    readonly sealed: {
        readonly name: "checkIsObjectSealed";
        readonly typeName: "ObjectSealed";
    } & ((v: unknown) => boolean);
    /** @checks `T & Record\<K, unknown\>` */
    readonly plain: {
        readonly name: "checkIsObject";
        readonly typeName: "Object";
    } & ((v: unknown) => boolean);
    /** @checks `Map\<K, V\>` */
    readonly mapWithEntries: {
        readonly name: "checkIsMapWithEntries";
        readonly typeName: "MapWithEntries";
    } & ((v: unknown, validators: Record<string, (x: unknown) => x is unknown>) => boolean);
    /** @checks `Map\<K, unknown\>` */
    readonly mapWithKeys: {
        readonly name: "checkIsMapWithKeys";
        readonly typeName: "MapWithKeys";
    } & ((v: unknown, keys: readonly string[]) => boolean);
    /** @checks `Map\<unknown, V\>` */
    readonly mapWithValues: {
        readonly name: "checkIsMapWithValues";
        readonly typeName: "MapWithValues";
    } & ((v: unknown, valueGuard: (x: unknown) => x is unknown) => boolean);
    /** @checks `Set<T>` */
    readonly setOf: {
        readonly name: "checkIsSetOf";
        readonly typeName: "SetOf";
    } & ((v: unknown, valueValidator: (val: unknown) => val is unknown) => boolean);
};