@augment-vir/assert/dist/augments/guards/check.d.ts

import { AnyFunction } from '@augment-vir/core';
declare const checkGroup: import("../../guard-types/check-function.js").CheckGroup<{
    output: {
        <const FunctionToCall extends AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
        <const FunctionToCall extends AnyFunction>(asserter: import("../assertion-exports.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
    };
    isHttpStatus: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").HttpStatus;
    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
    hasValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
    lacksValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
    hasValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
    lacksValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
    isIn: typeof import("../../assertions/values.js").isIn;
    isNotIn: <const Parent extends object | string, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => asserts child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("../assertion-exports.js").Empty>;
    isUuid: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").Uuid;
    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
    throws: {
        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<void>;
        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
        (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<void>;
    };
    isError: (actual: unknown, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
    strictEquals: typeof import("../../assertions/equality/simple-equality.js").strictEquals;
    notStrictEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
    looseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
    notLooseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
    deepEquals: typeof import("../../assertions/equality/simple-equality.js").deepEquals;
    notDeepEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
    isArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>;
    isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
    isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, AnyFunction>;
    isNull: (actual: unknown, failureMessage?: string | undefined) => asserts actual is null;
    isNumber: (actual: unknown, failureMessage?: string | undefined) => asserts actual is number;
    isObject: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").UnknownObject;
    isString: (actual: unknown, failureMessage?: string | undefined) => asserts actual is string;
    isSymbol: (actual: unknown, failureMessage?: string | undefined) => asserts actual is symbol;
    isUndefined: (actual: unknown, failureMessage?: string | undefined) => asserts actual is undefined;
    isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
    isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, bigint>;
    isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, boolean>;
    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, AnyFunction>;
    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
    isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, number>;
    isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
    isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, string>;
    isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, symbol>;
    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, undefined>;
    matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
    mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
    isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
    isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, PromiseLike<any>>;
    isPromise: (actual: unknown, failureMessage?: string | undefined) => asserts actual is Promise<any>;
    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, Promise<any>>;
    isPropertyKey: (input: unknown, failureMessage?: string | undefined) => asserts input is PropertyKey;
    isNotPropertyKey: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, PropertyKey>;
    isPrimitive: (input: unknown, failureMessage?: string | undefined) => asserts input is import("type-fest").Primitive;
    isNotPrimitive: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, import("type-fest").Primitive>;
    isAbove: (actual: number, expected: number, failureMessage?: string | undefined) => void;
    isAtLeast: (actual: number, expected: number, failureMessage?: string | undefined) => void;
    isBelow: (actual: number, expected: number, failureMessage?: string | undefined) => void;
    isAtMost: (actual: number, expected: number, failureMessage?: string | undefined) => void;
    isNaN: (actual: number, failureMessage?: string | undefined) => void;
    isFinite: (actual: number, failureMessage?: string | undefined) => void;
    isInfinite: (actual: number, failureMessage?: string | undefined) => void;
    isApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
    isNotApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
    isDefined: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, undefined | null>;
    isNullish: (input: unknown, failureMessage?: string | undefined) => asserts input is null | undefined;
    isLengthAtLeast: {
        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
    };
    isLengthExactly: {
        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").Tuple<Element, Length>;
        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
    };
    isKeyOf: <const Parent>(key: PropertyKey, parent: Parent, failureMessage?: string | undefined) => asserts key is keyof Parent;
    isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => asserts key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
    hasKey: <const Key extends PropertyKey, const Parent>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Parent & Record<Key, (Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
    lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Record<Key, any>>;
    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => asserts parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
    jsonEquals: <const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
    notJsonEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
    instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Instance;
    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Exclude<Actual, Instance>;
    isEnumValue: typeof import("../../assertions/enum.js").isEnumValue;
    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => asserts child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
    entriesEqual: <const Actual extends object, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
    notEntriesEqual: (actual: object, expected: object, failureMessage?: string | undefined) => void;
    endsWith: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
        (parent: string, child: string, failureMessage?: string | undefined): void;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
    };
    endsWithout: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
        (parent: string, child: string, failureMessage?: string | undefined): void;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
    };
    startsWith: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
        (parent: string, child: string, failureMessage?: string | undefined): void;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
    };
    startsWithout: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
        (parent: string, child: string, failureMessage?: string | undefined): void;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
    };
    isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
    isFalsy: (input: unknown, failureMessage?: string | undefined) => asserts input is import("../assertion-exports.js").FalsyValue;
    isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("../assertion-exports.js").Truthy<Actual>;
}, {
    isFalse: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isFalsy: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isTrue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isTruthy: <T>(input: T) => input is import("../assertion-exports.js").Truthy<T>;
} & {
    strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
    notStrictEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    looseEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    notLooseEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
    notDeepEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    output: {
        <const FunctionToCall extends AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? boolean : Promise<boolean> : boolean;
        <const FunctionToCall extends AnyFunction>(asserter: import("../assertion-exports.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? boolean : Promise<boolean> : boolean;
    };
} & {
    isArray: <Actual>(actual: Actual) => actual is Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>;
    isBigInt: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isBoolean: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToActual<Actual, AnyFunction>;
    isNull: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNumber: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isObject: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isString: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isSymbol: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isUndefined: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, ReadonlyArray<unknown>>;
    isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, bigint>;
    isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, boolean>;
    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, AnyFunction>;
    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, null>;
    isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, number>;
    isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
    isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, string>;
    isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, symbol>;
    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, undefined>;
} & {
    throws: {
        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): boolean;
        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): Promise<boolean>;
        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): boolean;
        (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): import("@augment-vir/core").MaybePromise<boolean>;
    };
    isError: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    hasValue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    lacksValue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    hasValues: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    lacksValues: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isIn: <const Parent>(child: unknown, parent: Parent) => child is import("@augment-vir/core").Values<Parent>;
    isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => actual is import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => actual is Exclude<Actual, import("../assertion-exports.js").Empty>;
} & {
    endsWith: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
        (parent: string, child: string, failureMessage?: string | undefined): boolean;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
    };
    endsWithout: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
        (parent: string, child: string, failureMessage?: string | undefined): boolean;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
    };
    startsWith: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
        (parent: string, child: string, failureMessage?: string | undefined): boolean;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
    };
    startsWithout: {
        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
        (parent: string, child: string, failureMessage?: string | undefined): boolean;
        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
    };
} & {
    isEnumValue: <const Expected extends import("@augment-vir/core").EnumBaseType>(child: unknown, checkEnum: Expected) => child is Expected[keyof Expected];
    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
} & {
    entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
    notEntriesEqual: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
    notJsonEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    isHttpStatus: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
} & {
    instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>) => instance is Instance;
    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>) => instance is Exclude<Actual, Instance>;
} & {
    isKeyOf: <const Parent>(key: PropertyKey, parent: Parent) => key is keyof Parent;
    isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
    hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => parent is Parent & Record<Key, (Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
    lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => parent is Exclude<Parent, Record<Key, any>>;
    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => parent is Exclude<Parent, Partial<Record<Key, any>>>;
} & {
    isLengthAtLeast: {
        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
        (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
    };
    isLengthExactly: {
        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is import("@augment-vir/core").Tuple<Element, Length>;
        (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
    };
} & {
    isDefined: <Actual>(input: Actual) => input is Exclude<Actual, undefined | null>;
    isNullish: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    isAbove: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isAtLeast: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isBelow: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isAtMost: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNaN: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isFinite: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isInfinite: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isApproximately: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNotApproximately: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    isNotPrimitive: <const Actual>(input: Actual) => input is Exclude<Actual, import("type-fest").Primitive>;
    isNotPropertyKey: <const Actual>(input: Actual) => input is Exclude<Actual, PropertyKey>;
    isPrimitive: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isPropertyKey: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    isPromiseLike: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, PromiseLike<any>>;
    isPromise: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
} & {
    matches: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    mismatches: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
} & {
    isUuid: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
}>;
/**
 * A group of guard methods that return a boolean type guard rather than an assertion type guard.
 *
 * This can also be called as a standalone check function which returns a boolean to indicate
 * whether its input is truthy or not.
 *
 * @category Assert
 * @category Package : @augment-vir/assert
 * @example
 *
 * ```ts
 * import {check} from '@augment-vir/assert';
 *
 * const value: unknown = 'some value' as unknown;
 * if (check.isString(value)) {
 *     // `value` will now be typed as a `string` in here
 * }
 * ```
 *
 * @returns A boolean (as a type guard when possible).
 * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
 */
export declare const check: ((input: unknown) => boolean) & typeof checkGroup & Record<keyof AnyFunction, never>;
export {};