@augment-vir/assert 30.0.4 → 30.0.5

package/dist/augments/guards/check.d.ts

@@ -1,258 +1,7 @@
-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>;
-}>;
+import type { AnyFunction } from '@augment-vir/core';
+import { checkOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
+import { CheckGroup } from '../../guard-types/check-function.js';
+declare const checkGroup: CheckGroup<typeof extendableAssertions, typeof checkOverrides>;
 /**
  * A group of guard methods that return a boolean type guard rather than an assertion type guard.
  *

package/dist/augments/guards/wait-until.d.ts

@@ -1,232 +1,6 @@
-import { AnyFunction } from '@augment-vir/core';
-import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
-declare const waitUntilGroup: {
-    endsWith: {
-        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-    };
-    startsWith: {
-        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-    };
-    isFalse: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, false>>;
-    isFalsy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("../assertion-exports.js").Falsy<Actual>>;
-    isTrue: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, true>>;
-    isTruthy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("../assertion-exports.js").Truthy<Actual>>;
-    strictEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
-    notStrictEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    looseEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    notLooseEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    deepEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
-    notDeepEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    output: typeof import("../../assertions/output.js").waitUntilOutput;
-    isArray: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<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: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, bigint>>;
-    isBoolean: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, boolean>>;
-    isFunction: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, AnyFunction>>;
-    isNull: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, null>>;
-    isNumber: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, number>>;
-    isObject: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, import("@augment-vir/core").UnknownObject>>;
-    isString: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, string>>;
-    isSymbol: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, symbol>>;
-    isUndefined: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, undefined>>;
-    isNotArray: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, ReadonlyArray<unknown>>>;
-    isNotBigInt: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, bigint>>;
-    isNotBoolean: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, boolean>>;
-    isNotFunction: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, AnyFunction>>;
-    isNotNull: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, null>>;
-    isNotNumber: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, number>>;
-    isNotObject: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").UnknownObject>>;
-    isNotString: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, string>>;
-    isNotSymbol: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, symbol>>;
-    isNotUndefined: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
-    throws: {
-        (callback: import("@augment-vir/core").TypedFunction<void, any>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
-        (matchOptions: import("../assertion-exports.js").ErrorMatchOptions, callback: import("@augment-vir/core").TypedFunction<void, any>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
-    };
-    isError: <Input extends unknown>(matchOptions: import("@augment-vir/core").PartialWithNullable<{
-        matchMessage: string | RegExp;
-        matchConstructor: ErrorConstructor | (new (...args: any[]) => Error);
-    }> | undefined, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, Error>>;
-    hasValue: <Input extends object>(value: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    lacksValue: <Input extends object>(value: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    hasValues: <Input extends object>(values: readonly unknown[], params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    lacksValues: <Input extends object>(values: readonly unknown[], params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isIn: <const Child, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>>>;
-    isNotIn: <const Child, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Child, import("@augment-vir/core").Values<Parent>>>;
-    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>>;
-    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("../assertion-exports.js").Empty>>;
-    endsWithout: {
-        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-    };
-    startsWithout: {
-        <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
-        (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-    };
-    isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(checkEnum: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]>>;
-    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(checkEnum: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>>;
-    entriesEqual: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
-    notEntriesEqual: <Input extends object>(expected: object, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    jsonEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
-    notJsonEquals: <Input extends unknown>(expected: unknown, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isHttpStatus: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, import("@augment-vir/core").HttpStatus>>;
-    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(category: Category, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>>;
-    instanceOf: <const Instance>(constructor: import("type-fest").Constructor<Instance>, callback: () => import("@augment-vir/core").MaybePromise<unknown>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Instance>;
-    notInstanceOf: <const Actual, const Instance>(constructor: import("type-fest").Constructor<Instance>, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Instance>>;
-    isKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Key, keyof Parent>>;
-    isNotKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Key>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>>;
-    hasKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<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>(key: Key, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Record<Key, any>>>;
-    hasKeys: <const Keys extends PropertyKey, const Parent>(keys: ReadonlyArray<Keys>, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<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 Keys extends PropertyKey>(keys: ReadonlyArray<Keys>, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Partial<Record<Keys, any>>>>;
-    isLengthAtLeast: {
-        <Element, Length extends number>(length: Length, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<Element | undefined>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<import("@augment-vir/core").AtLeastTuple<Element, Length>>;
-        <Actual extends string | import("@augment-vir/core").AnyObject>(length: number, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
-    };
-    isLengthExactly: {
-        <Element, Length extends number>(length: Length, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<Element | undefined>>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<import("@augment-vir/core").Tuple<Element, Length>>;
-        <Actual extends string | import("@augment-vir/core").AnyObject>(length: number, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
-    };
-    isDefined: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined | null>>;
-    isNullish: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, null | undefined>>;
-    isAbove: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isAtLeast: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isBelow: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isAtMost: <Input extends number>(expected: number, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isNaN: <Input extends number>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isFinite: <Input extends number>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isInfinite: <Input extends number>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isApproximately: <Input extends number>(expected: number, delta: number, params_2: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isNotApproximately: <Input extends number>(expected: number, delta: number, params_2: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isPropertyKey: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, PropertyKey>>;
-    isNotPropertyKey: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PropertyKey>>;
-    isPrimitive: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, import("type-fest").Primitive>>;
-    isNotPrimitive: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("type-fest").Primitive>>;
-    isPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, PromiseLike<any>>>;
-    isNotPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PromiseLike<any>>>;
-    isPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, Promise<any>>>;
-    isNotPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
-    matches: <Input extends string>(expected: RegExp, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    mismatches: <Input extends string>(expected: RegExp, params_1: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isUuid: <Input extends unknown>(params_0: () => import("@augment-vir/core").MaybePromise<Input>, options?: import("@augment-vir/core").PartialWithUndefined<{
-        interval: import("@date-vir/duration").AnyDuration;
-        timeout: import("@date-vir/duration").AnyDuration;
-    }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, `${string}-${string}-${string}-${string}-${string}`>>;
-    isNotUuid: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").Uuid>>;
-};
+import { extendableAssertions, waitUntilOverrides } from '../../assertions/extendable-assertions.js';
+import { type WaitUntilGroup, type WaitUntilOptions } from '../../guard-types/wait-until-function.js';
+declare const waitUntilGroup: WaitUntilGroup<typeof extendableAssertions, typeof waitUntilOverrides>;
 /**
  * A group of guard methods that run the given callback multiple times until its return value
  * matches expectations. Callback interval and timeout can be customized with

package/dist/guard-types/assert-wrap-function.d.ts

@@ -1,5 +1,5 @@
-import { AnyFunction, ExtractKeysWithMatchingValues, NarrowToExpected, Overwrite } from '@augment-vir/core';
-import { AssertFunction } from './assert-function.js';
+import { type AnyFunction, type ExtractKeysWithMatchingValues, type NarrowToExpected, type Overwrite } from '@augment-vir/core';
+import { type AssertFunction } from './assert-function.js';
 import { autoGuardSymbol } from './guard-override.js';
 export type AssertWrapFunction<Output> = <Input>(input: Input, ...extraInputs: any[]) => NarrowToExpected<Input, Output>;
 export type AssertWrapOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, AnyFunction | undefined | typeof autoGuardSymbol>>;

package/dist/guard-types/check-function.d.ts

@@ -1,5 +1,5 @@
-import { ExtractKeysWithMatchingValues, MaybePromise, Overwrite, RemoveFirstTupleEntry, RemoveLastTupleEntry } from '@augment-vir/core';
-import { AssertFunction } from './assert-function.js';
+import type { ExtractKeysWithMatchingValues, MaybePromise, Overwrite, RemoveFirstTupleEntry, RemoveLastTupleEntry } from '@augment-vir/core';
+import { type AssertFunction } from './assert-function.js';
 import { type autoGuardSymbol } from './guard-override.js';
 export type CheckFunction<Output> = (input: any, ...extraInputs: any[]) => input is Output;
 export type GenericCheckFunction = (input: any, ...extraInputs: any[]) => MaybePromise<boolean> | never;

package/dist/guard-types/check-wrap-wrapper-function.d.ts

@@ -1,6 +1,6 @@
-import { ExtractKeysWithMatchingValues, Overwrite, type NarrowToActual } from '@augment-vir/core';
-import { AssertFunction } from './assert-function.js';
-import { AssertWrapOverridesBase } from './assert-wrap-function.js';
+import type { ExtractKeysWithMatchingValues, NarrowToActual, Overwrite } from '@augment-vir/core';
+import { type AssertFunction } from './assert-function.js';
+import { type AssertWrapOverridesBase } from './assert-wrap-function.js';
 import { autoGuardSymbol } from './guard-override.js';
 export type CheckWrapFunction<Output> = <Input>(input: Input, ...extraInputs: any[]) => NarrowToActual<Input, Output> | undefined;
 export type CheckWrapGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, CheckWrapOverrides extends AssertWrapOverridesBase> = Omit<Overwrite<{

package/dist/guard-types/guard-override.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject, Values } from '@augment-vir/core';
+import type { AnyObject, Values } from '@augment-vir/core';
 export declare const autoGuardSymbol: unique symbol;
 export declare function autoGuard<T>(): T;
 export declare function pickOverride<Overrides extends AnyObject, Created>(overrides: Overrides, name: string, create: () => Created): Values<Overrides> | Created;