@augment-vir/assert 30.0.0 → 30.0.2

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

@@ -1,48 +1,27 @@
+import { AnyFunction } from '@augment-vir/core';
 import { WaitUntilOptions } from '../../guard-types/wait-until-function.js';
-/**
- * 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
- * {@link WaitUntilOptions}.
- *
- * @category Assert
- * @example
- *
- * ```ts
- * import {waitUntil} from '@augment-vir/assert';
- *
- * // `result` will eventually be `'123'`
- * const result = await waitUntil.isString(
- *     () => {
- *         if (Math.random() < 0.5) {
- *             return 123;
- *         } else {
- *             return '123';
- *         }
- *     },
- *     {
- *         interval: {milliseconds: 100},
- *         timeout: {seconds: 10},
- *     },
- * );
- * ```
- *
- * @returns The successful callback return value.
- * @throws {@link AssertionError} When the assertion fails.
- * @package @augment-vir/assert
- */
-export declare const waitUntil: {
-    isTruthy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("../assertion-exports.js").Truthy<Actual>>;
+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>>;
-    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>>;
+    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>>;
-    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>>;
     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;
@@ -55,30 +34,12 @@ export declare const waitUntil: {
         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;
-    isFunction: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>>;
-    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, import("@augment-vir/core").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>>;
-    isNotUndefined: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
-    isNotSymbol: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, symbol>>;
-    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>>;
     isArray: <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;
@@ -91,6 +52,7 @@ export declare const waitUntil: {
         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;
@@ -107,9 +69,27 @@ export declare const waitUntil: {
         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: {
-        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, any> | Promise<any>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
-        (matchOptions: import("../assertion-exports.js").ErrorMatchOptions, callbackOrPromise: import("@augment-vir/core").TypedFunction<void, any> | Promise<any>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
+        (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;
@@ -118,12 +98,32 @@ export declare const waitUntil: {
         interval: import("@date-vir/duration").AnyDuration;
         timeout: import("@date-vir/duration").AnyDuration;
     }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, Error>>;
-    endsWith: {
+    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>>;
     };
-    startsWith: {
+    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>>;
@@ -140,18 +140,18 @@ export declare const waitUntil: {
         interval: import("@date-vir/duration").AnyDuration;
         timeout: import("@date-vir/duration").AnyDuration;
     }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    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>>>;
     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("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>>;
+    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("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>>;
+    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>>;
@@ -202,45 +202,20 @@ export declare const waitUntil: {
         interval: import("@date-vir/duration").AnyDuration;
         timeout: import("@date-vir/duration").AnyDuration;
     }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    isNotPrimitive: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("type-fest").Primitive>>;
-    isNotPropertyKey: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PropertyKey>>;
     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>>;
-    isNotPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
+    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>>>;
-    isPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, PromiseLike<any>>>;
-    isNotUuid: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").Uuid>>;
-    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}`>>;
-    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>>;
+    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;
@@ -249,14 +224,46 @@ export declare const waitUntil: {
         interval: import("@date-vir/duration").AnyDuration;
         timeout: import("@date-vir/duration").AnyDuration;
     }> | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Input, unknown>>;
-    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>>;
-    };
+    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>>;
 };
+/**
+ * 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
+ * {@link WaitUntilOptions}.
+ *
+ * This can also be called as a standalone wait until function which waits until the callback's
+ * returned value is truthy.
+ *
+ * @category Assert
+ * @category Package : @augment-vir/assert
+ * @example
+ *
+ * ```ts
+ * import {waitUntil} from '@augment-vir/assert';
+ *
+ * // `result` will eventually be `'123'`
+ * const result = await waitUntil.isString(
+ *     () => {
+ *         if (Math.random() < 0.5) {
+ *             return 123;
+ *         } else {
+ *             return '123';
+ *         }
+ *     },
+ *     {
+ *         interval: {milliseconds: 100},
+ *         timeout: {seconds: 10},
+ *     },
+ * );
+ * ```
+ *
+ * @returns The successful callback return value.
+ * @throws {@link AssertionError} When the assertion fails.
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export declare const waitUntil: (<T>(callback: () => T, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<T>) & typeof waitUntilGroup;
+export {};

package/dist/augments/guards/wait-until.js

@@ -1,11 +1,17 @@
 import { extendableAssertions, waitUntilOverrides } from '../../assertions/extendable-assertions.js';
-import { createWaitUntilGroup } from '../../guard-types/wait-until-function.js';
+import { createWaitUntilGroup, executeWaitUntil, } from '../../guard-types/wait-until-function.js';
+import { AssertionError } from '../assertion.error.js';
+const waitUntilGroup = createWaitUntilGroup(extendableAssertions, 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
  * {@link WaitUntilOptions}.
  *
+ * This can also be called as a standalone wait until function which waits until the callback's
+ * returned value is truthy.
+ *
  * @category Assert
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -29,6 +35,15 @@ import { createWaitUntilGroup } from '../../guard-types/wait-until-function.js';
  *
  * @returns The successful callback return value.
  * @throws {@link AssertionError} When the assertion fails.
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export const waitUntil = createWaitUntilGroup(extendableAssertions, waitUntilOverrides);
+export const waitUntil = Object.assign(function waitUntil(input, failureMessage) {
+    return executeWaitUntil((input, failureMessage) => {
+        if (!input) {
+            throw new AssertionError('Assertion failed.', failureMessage);
+        }
+    }, [
+        input,
+        failureMessage,
+    ], false);
+}, waitUntilGroup);

package/dist/augments/if-equals.d.ts

@@ -4,7 +4,8 @@ import type { IsEqual } from 'type-fest';
  * Otherwise it resolves to the given `No` type parameter.
  *
  * @category Assert : Util
- * @package @augment-vir/assert
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
 export type IfEquals<Actual, Expected, Yes = unknown, No = never> = IsEqual<Actual, Expected> extends true ? Yes : No;
 /**
@@ -12,6 +13,7 @@ export type IfEquals<Actual, Expected, Yes = unknown, No = never> = IsEqual<Actu
  * Otherwise it resolves to the given `No` type parameter.
  *
  * @category Assert : Util
- * @package @augment-vir/assert
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
 export type IfExtends<Actual, Expected, Yes = unknown, No = never> = Actual extends Expected ? Yes : No;

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

@@ -1,9 +1,12 @@
 import { AnyFunction, ExtractKeysWithMatchingValues, NarrowToExpected, Overwrite } from '@augment-vir/core';
 import { 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 = Readonly<Record<string, AnyFunction | undefined>>;
+export type AssertWrapOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, AnyFunction | undefined | typeof autoGuardSymbol>>;
 export type AssertWrapGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, AssertWrapOverrides extends AssertWrapOverridesBase> = Omit<Overwrite<{
     [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? AssertWrapFunction<Output> : never;
-}, AssertWrapOverrides>, ExtractKeysWithMatchingValues<AssertWrapOverrides, undefined>>;
+}, {
+    [Name in keyof AssertWrapOverrides]: AssertWrapOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<infer Output> ? AssertWrapFunction<Output> : never : never : AssertWrapOverrides[Name];
+}>, ExtractKeysWithMatchingValues<AssertWrapOverrides, undefined>>;
 export declare function createAssertWrapGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const AssertWrapOverrides extends AssertWrapOverridesBase>(asserts: Asserts, assertWrapOverrides: AssertWrapOverrides): AssertWrapGroup<Asserts, AssertWrapOverrides>;
 export declare function createAssertWrap<const Output>(assert: AssertFunction<Output>): AssertWrapFunction<Output>;

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

@@ -1,11 +1,14 @@
 import { ExtractKeysWithMatchingValues, MaybePromise, Overwrite, RemoveFirstTupleEntry, RemoveLastTupleEntry } from '@augment-vir/core';
 import { 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;
-export type CheckOverridesBase = Readonly<Record<string, CheckFunction<any> | GenericCheckFunction | undefined>>;
+export type CheckOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, CheckFunction<any> | GenericCheckFunction | undefined | typeof autoGuardSymbol>>;
 export type CheckGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, CheckOverrides extends CheckOverridesBase> = Omit<Overwrite<{
     [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? (input: Parameters<Asserts[Name]>[0], ...params: RemoveLastTupleEntry<RemoveFirstTupleEntry<Parameters<Asserts[Name]>>>) => input is Output : never;
-}, CheckOverrides>, ExtractKeysWithMatchingValues<CheckOverrides, undefined>>;
+}, {
+    [Name in keyof CheckOverrides]: CheckOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<infer Output> ? (input: Parameters<Asserts[Name]>[0], ...params: RemoveLastTupleEntry<RemoveFirstTupleEntry<Parameters<Asserts[Name]>>>) => input is Output : never : never : CheckOverrides[Name];
+}>, ExtractKeysWithMatchingValues<CheckOverrides, undefined>>;
 export declare function createCheckGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const CheckOverrides extends CheckOverridesBase>(asserts: Asserts, checkOverrides: CheckOverrides): CheckGroup<Asserts, CheckOverrides>;
 export declare function createCheck<const Output>(assert: AssertFunction<Output>): CheckFunction<Output>;
 export declare function runAssertCheck<const Output, const Assert extends AssertFunction<Output>>(assert: Assert, input: Parameters<Assert>[0], ...inputs: RemoveFirstTupleEntry<RemoveLastTupleEntry<Parameters<Assert>>>): input is Output;

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

@@ -1,9 +1,12 @@
 import { ExtractKeysWithMatchingValues, Overwrite, type NarrowToActual } from '@augment-vir/core';
 import { AssertFunction } from './assert-function.js';
 import { 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<{
     [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: Asserts[Name] extends AssertFunction<infer Output> ? CheckWrapFunction<Output> : never;
-}, CheckWrapOverrides>, ExtractKeysWithMatchingValues<CheckWrapOverrides, undefined>>;
+}, {
+    [Name in keyof CheckWrapOverrides]: CheckWrapOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<infer Output> ? CheckWrapFunction<Output> : never : never : CheckWrapOverrides[Name];
+}>, ExtractKeysWithMatchingValues<CheckWrapOverrides, undefined>>;
 export declare function createCheckWrapGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const CheckWrapOverrides extends AssertWrapOverridesBase>(asserts: Asserts, checkWrapOverrides: CheckWrapOverrides): CheckWrapGroup<Asserts, CheckWrapOverrides>;
 export declare function createCheckWrap<const Output>(assert: AssertFunction<Output>): CheckWrapFunction<Output>;

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

@@ -3,11 +3,10 @@ import type { AssertFunction } from './assert-function.js';
 import type { AssertWrapOverridesBase } from './assert-wrap-function.js';
 import type { CheckOverridesBase } from './check-function.js';
 import type { WaitUntilOverridesBase } from './wait-until-function.js';
-export type GuardGroup = {
-    assertions: Record<string, AssertFunction<any>>;
-} & Partial<{
-    checkOverrides: CheckOverridesBase;
-    assertWrapOverrides: AssertWrapOverridesBase;
-    checkWrapOverrides: AssertWrapOverridesBase;
-    waitUntilOverrides: WaitUntilOverridesBase;
-}>;
+export type GuardGroup<Assertions extends Record<string, AssertFunction<any>>> = {
+    assert: Assertions;
+    check: CheckOverridesBase<keyof Assertions>;
+    assertWrap: AssertWrapOverridesBase<keyof Assertions>;
+    checkWrap: AssertWrapOverridesBase<keyof Assertions>;
+    waitUntil: WaitUntilOverridesBase<keyof Assertions>;
+};

package/dist/guard-types/wait-until-function.d.ts

@@ -2,11 +2,13 @@ import type { AnyFunction, MaybePromise, NarrowToExpected, PartialWithUndefined,
 import { ExtractKeysWithMatchingValues, Overwrite } from '@augment-vir/core';
 import { AnyDuration } from '@date-vir/duration';
 import type { AssertFunction } from './assert-function.js';
+import { autoGuardSymbol } from './guard-override.js';
 /**
  * Options for configuring the timing of `waitUntil`.
  *
  * @category Assert : Util
- * @package @augment-vir/assert
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
 export type WaitUntilOptions = PartialWithUndefined<{
     /**
@@ -24,7 +26,8 @@ export type WaitUntilOptions = PartialWithUndefined<{
     timeout: AnyDuration;
 }>;
 export declare const defaultWaitUntilOptions: RequiredAndNotNull<WaitUntilOptions>;
-export type WaitUntilOverridesBase = Readonly<Record<string, AnyFunction>>;
+export declare function executeWaitUntil<const Assert extends AssertFunction<any>>(this: void, assert: AssertFunction<any>, rawArgs: unknown[], requireSynchronousResult: boolean): Promise<ReturnType<WaitUntilFunction<Assert>>>;
+export type WaitUntilOverridesBase<Keys extends PropertyKey = string> = Readonly<Record<Keys, AnyFunction | typeof autoGuardSymbol | undefined>>;
 export type WaitUntilFunctionParameters<Assert extends AssertFunction<any>, Input> = [
     ...RemoveFirstTupleEntry<RemoveLastTupleEntry<Parameters<Assert>>>,
     () => MaybePromise<Input>
@@ -36,7 +39,9 @@ export type WaitUntilFunction<Assert extends AssertFunction<any>> = Assert exten
 ]) => Promise<NarrowToExpected<Input, Guard>> : never;
 type WaitUntilGroup<Asserts extends Readonly<Record<string, AssertFunction<any>>>, WaitUntilOverrides extends WaitUntilOverridesBase> = Omit<Overwrite<{
     [Name in keyof Asserts as Asserts[Name] extends AssertFunction<any> ? Name : never]: WaitUntilFunction<Asserts[Name]>;
-}, WaitUntilOverrides>, ExtractKeysWithMatchingValues<WaitUntilOverrides, undefined>>;
+}, {
+    [Name in keyof WaitUntilOverrides]: WaitUntilOverrides[Name] extends typeof autoGuardSymbol ? Name extends keyof Asserts ? Asserts[Name] extends AssertFunction<any> ? WaitUntilFunction<Asserts[Name]> : never : never : WaitUntilOverrides[Name];
+}>, ExtractKeysWithMatchingValues<WaitUntilOverrides, undefined>>;
 export declare function createWaitUntilGroup<const Asserts extends Readonly<Record<string, AssertFunction<any>>>, const WaitUntilOverrides extends WaitUntilOverridesBase>(asserts: Asserts, waitUntilOverrides: WaitUntilOverrides): WaitUntilGroup<Asserts, WaitUntilOverrides>;
 export declare function createWaitUntil<const Assert extends AssertFunction<any>>(assert: Assert, requireSynchronousResult?: boolean): WaitUntilFunction<Assert>;
 export declare function parseWaitUntilArgs(rawArgs: unknown[]): {

package/dist/guard-types/wait-until-function.js

@@ -10,7 +10,7 @@ export const defaultWaitUntilOptions = {
     },
 };
 const notSetSymbol = Symbol('not set');
-async function executeWaitUntil(assert, rawArgs, requireSynchronousResult) {
+export async function executeWaitUntil(assert, rawArgs, requireSynchronousResult) {
     const { callback, extraAssertionArgs, failureMessage, options } = parseWaitUntilArgs(rawArgs);
     const timeout = convertDuration(options.timeout, DurationUnit.Milliseconds).milliseconds;
     const interval = convertDuration(options.interval, DurationUnit.Milliseconds);

package/package.json

@@ -1,6 +1,21 @@
 {
     "name": "@augment-vir/assert",
-    "version": "30.0.0",
+    "version": "30.0.2",
+    "description": "A collection of assertions for test and production code alike.",
+    "keywords": [
+        "augment",
+        "helper",
+        "util",
+        "node",
+        "browser",
+        "backend",
+        "frontend",
+        "assert",
+        "test",
+        "chai",
+        "vir",
+        "augment-vir"
+    ],
     "homepage": "https://github.com/electrovir/augment-vir",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"
@@ -20,30 +35,28 @@
     "types": "dist/index.d.ts",
     "scripts": {
         "compile": "virmator compile",
-        "docs": "virmator docs",
         "start": "tsx src/index.ts",
         "test": "virmator test node --no-deps",
         "test:coverage": "npm run test coverage",
-        "test:docs": "virmator docs check",
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/core": "^30.0.0",
+        "@augment-vir/core": "^30.0.2",
         "@date-vir/duration": "^6.0.0",
         "deep-eql": "^5.0.2",
         "expect-type": "^0.20.0",
-        "type-fest": "^4.25.0"
+        "type-fest": "^4.26.1"
     },
     "devDependencies": {
         "@types/deep-eql": "^4.0.2",
         "@web/dev-server-esbuild": "^1.0.2",
-        "@web/test-runner": "^0.18.3",
+        "@web/test-runner": "^0.19.0",
         "@web/test-runner-commands": "^0.9.0",
         "@web/test-runner-playwright": "^0.11.0",
-        "@web/test-runner-visual-regression": "^0.9.0",
+        "@web/test-runner-visual-regression": "^0.10.0",
         "c8": "^10.1.2",
         "istanbul-smart-text-reporter": "^1.1.4",
-        "typescript": "^5.5.4"
+        "typescript": "^5.6.2"
     },
     "engines": {
         "node": ">=22"