@augment-vir/assert 31.0.0 → 31.0.1

package/dist/assertions/values.d.ts

@@ -1,14 +1,8 @@
 import type { NarrowToActual, NarrowToExpected } from '@augment-vir/core';
 import { type AnyObject, type MaybePromise, type Values } from '@augment-vir/core';
 import type { EmptyObject } from 'type-fest';
-import { autoGuardSymbol } from '../guard-types/guard-override.js';
 import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
-declare function hasValue(parent: object, value: unknown, failureMessage?: string | undefined): void;
-declare function lacksValue(parent: object, value: unknown, failureMessage?: string | undefined): void;
-declare function hasValues(parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined): void;
-declare function lacksValues(parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined): void;
-export declare function isIn<const Parent extends object | string>(child: unknown, parent: Parent, failureMessage?: string | undefined): asserts child is Values<Parent>;
-declare function isNotIn<const Parent extends object | string, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined): asserts child is Exclude<Child, Values<Parent>>;
+export declare function isIn<Parent extends object | string>(this: void, child: unknown, parent: Parent): child is Values<Parent>;
 /**
  * All types that can be checked for emptiness. The empty variants of these types are represented in
  * {@link Empty}.
@@ -28,8 +22,6 @@ export type CanBeEmpty = string | Map<any, any> | Set<any> | AnyObject | any[];
  * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
 export type Empty = '' | EmptyObject | [] | Map<any, any> | Set<any>;
-declare function isEmpty<const Actual extends CanBeEmpty>(actual: Actual, failureMessage?: string | undefined): asserts actual is NarrowToActual<Actual, Empty>;
-declare function isNotEmpty<const Actual extends CanBeEmpty>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, Empty>;
 export declare const valueGuards: {
     assert: {
         /**
@@ -54,7 +46,7 @@ export declare const valueGuards: {
          * - {@link assert.lacksValue} : the opposite assertion.
          * - {@link assert.hasValues} : the multi-value assertion.
          */
-        hasValue: typeof hasValue;
+        hasValue(this: void, parent: object | string, value: unknown, failureMessage?: string | undefined): void;
         /**
          * Asserts that an object/array parent does _not_ include a child value through reference
          * equality.
@@ -78,7 +70,7 @@ export declare const valueGuards: {
          * - {@link assert.hasValue} : the opposite assertion.
          * - {@link assert.lacksValues} : the multi-value assertion.
          */
-        lacksValue: typeof lacksValue;
+        lacksValue(this: void, parent: object | string, value: unknown, failureMessage?: string | undefined): void;
         /**
          * Asserts that an object/array parent includes all child values through reference equality.
          *
@@ -92,21 +84,9 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * assert.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // passes
-         * assert.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // fails
-         * assert.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // passes
+         * assert.hasValues({child, child2}, [child, child2]); // passes
+         * assert.hasValues({child: {a: 'a'}, child2}, [child, child2]); // fails
+         * assert.hasValues([child], [child, child2]); // passes
          * ```
          *
          * @throws {@link AssertionError} If the assertion fails.
@@ -114,7 +94,7 @@ export declare const valueGuards: {
          * - {@link assert.lacksValues} : the opposite assertion.
          * - {@link assert.hasValue} : the single-value assertion.
          */
-        hasValues: typeof hasValues;
+        hasValues(this: void, parent: object | string, values: unknown[], failureMessage?: string | undefined): void;
         /**
          * Asserts that an object/array parent includes none of the provided child values through
          * reference equality.
@@ -129,18 +109,9 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * assert.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // passes
-         * assert.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // fails
-         * assert.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // fails
+         * assert.lacksValues({}, [child, child2]); // passes
+         * assert.lacksValues({child, child2}, [child, child2]); // fails
+         * assert.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // fails
          * ```
          *
          * @throws {@link AssertionError} If the assertion fails.
@@ -148,7 +119,7 @@ export declare const valueGuards: {
          * - {@link assert.lacksValues} : the opposite assertion.
          * - {@link assert.hasValue} : the single-value assertion.
          */
-        lacksValues: typeof lacksValues;
+        lacksValues(this: void, parent: object | string, values: unknown[], failureMessage?: string | undefined): void;
         /**
          * Asserts that child value is contained within a parent object, array, or string through
          * reference equality.
@@ -174,7 +145,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assert.isNotIn} : the opposite assertion.
          */
-        isIn: typeof isIn;
+        isIn<Parent extends object | string>(this: void, child: unknown, parent: Parent, failureMessage?: string | undefined): asserts child is Values<Parent>;
         /**
          * Asserts that child value is _not_ contained within a parent object, array, or string through
          * reference equality.
@@ -200,7 +171,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assert.isIn} : the opposite assertion.
          */
-        isNotIn: typeof isNotIn;
+        isNotIn<Parent extends object | string, Child>(this: void, child: Child, parent: Parent, failureMessage?: string | undefined): asserts child is Exclude<Child, Values<Parent>>;
         /**
          * Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -223,7 +194,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assert.isNotEmpty} : the opposite assertion.
          */
-        isEmpty: typeof isEmpty;
+        isEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual, failureMessage?: string | undefined): asserts actual is NarrowToActual<Actual, Empty>;
         /**
          * Asserts that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -246,7 +217,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assert.isEmpty} : the opposite assertion.
          */
-        isNotEmpty: typeof isNotEmpty;
+        isNotEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, Empty>;
     };
     check: {
         /**
@@ -270,7 +241,7 @@ export declare const valueGuards: {
          * - {@link check.lacksValue} : the opposite check.
          * - {@link check.hasValues} : the multi-value check.
          */
-        hasValue: typeof autoGuardSymbol;
+        hasValue(this: void, parent: object | string, value: unknown): boolean;
         /**
          * Checks that an object/array parent does _not_ include a child value through reference
          * equality.
@@ -293,7 +264,7 @@ export declare const valueGuards: {
          * - {@link check.hasValue} : the opposite check.
          * - {@link check.lacksValues} : the multi-value check.
          */
-        lacksValue: typeof autoGuardSymbol;
+        lacksValue(this: void, parent: object | string, value: unknown): boolean;
         /**
          * Checks that an object/array parent includes all child values through reference equality.
          *
@@ -307,28 +278,16 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * check.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `true`
-         * check.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `false`
-         * check.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // returns `true`
+         * check.hasValues({child, child2}, [child, child2]); // returns `true`
+         * check.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
+         * check.hasValues([child], [child, child2]); // returns `true`
          * ```
          *
          * @see
          * - {@link check.lacksValues} : the opposite check.
          * - {@link check.hasValue} : the single-value check.
          */
-        hasValues: typeof autoGuardSymbol;
+        hasValues(this: void, parent: object | string, values: unknown[]): boolean;
         /**
          * Checks that an object/array parent includes none of the provided child values through
          * reference equality.
@@ -343,25 +302,16 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * check.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // returns `true`
-         * check.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `false`
-         * check.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `false`
+         * check.lacksValues({}, [child, child2]); // returns `true`
+         * check.lacksValues({child, child2}, [child, child2]); // returns `false`
+         * check.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
          * ```
          *
          * @see
          * - {@link check.lacksValues} : the opposite check.
          * - {@link check.hasValue} : the single-value check.
          */
-        lacksValues: typeof autoGuardSymbol;
+        lacksValues(this: void, parent: object | string, values: unknown[]): boolean;
         /**
          * Checks that child value is contained within a parent object, array, or string through
          * reference equality.
@@ -386,7 +336,7 @@ export declare const valueGuards: {
          * @see
          * - {@link check.isNotIn} : the opposite check.
          */
-        isIn: <const Parent>(child: unknown, parent: Parent) => child is Values<Parent>;
+        isIn<Parent extends object | string>(this: void, child: unknown, parent: Parent): child is Values<Parent>;
         /**
          * Checks that child value is _not_ contained within a parent object, array, or string
          * through reference equality.
@@ -411,7 +361,7 @@ export declare const valueGuards: {
          * @see
          * - {@link check.isIn} : the opposite check.
          */
-        isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => child is Exclude<Child, Values<Parent>>;
+        isNotIn<Parent extends object | string, Child>(this: void, child: Child, parent: Parent): child is Exclude<Child, Values<Parent>>;
         /**
          * Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -433,7 +383,7 @@ export declare const valueGuards: {
          * @see
          * - {@link check.isNotEmpty} : the opposite check.
          */
-        isEmpty: <const Actual extends CanBeEmpty>(actual: Actual) => actual is NarrowToActual<Actual, Empty>;
+        isEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual): actual is NarrowToActual<Actual, Empty>;
         /**
          * Checks that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -455,7 +405,7 @@ export declare const valueGuards: {
          * @see
          * - {@link check.isEmpty} : the opposite check.
          */
-        isNotEmpty: <const Actual extends CanBeEmpty>(actual: Actual) => actual is Exclude<Actual, Empty>;
+        isNotEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual): actual is Exclude<Actual, Empty>;
     };
     assertWrap: {
         /**
@@ -482,7 +432,7 @@ export declare const valueGuards: {
          * - {@link assertWrap.lacksValue} : the opposite assertion.
          * - {@link assertWrap.hasValues} : the multi-value assertion.
          */
-        hasValue: typeof autoGuardSymbol;
+        hasValue<Parent extends object | string>(this: void, parent: Parent, value: unknown, failureMessage?: string | undefined): Parent;
         /**
          * Asserts that an object/array parent does _not_ include a child value through reference
          * equality. Returns the parent value if the assertion passes.
@@ -507,7 +457,7 @@ export declare const valueGuards: {
          * - {@link assertWrap.hasValue} : the opposite assertion.
          * - {@link assertWrap.lacksValues} : the multi-value assertion.
          */
-        lacksValue: typeof autoGuardSymbol;
+        lacksValue<Parent extends object | string>(this: void, parent: Parent, value: unknown, failureMessage?: string | undefined): Parent;
         /**
          * Asserts that an object/array parent includes all child values through reference equality.
          * Returns the parent value if the assertion passes.
@@ -522,21 +472,9 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * assertWrap.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{child, child2}`;
-         * assertWrap.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // throws an error
-         * assertWrap.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // returns `[child]`;
+         * assertWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`;
+         * assertWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
+         * assertWrap.hasValues([child], [child, child2]); // returns `[child]`;
          * ```
          *
          * @returns The value if the assertion passes.
@@ -545,7 +483,7 @@ export declare const valueGuards: {
          * - {@link assertWrap.lacksValues} : the opposite assertion.
          * - {@link assertWrap.hasValue} : the single-value assertion.
          */
-        hasValues: typeof autoGuardSymbol;
+        hasValues<Parent extends object | string>(this: void, parent: Parent, values: unknown[], failureMessage?: string | undefined): Parent;
         /**
          * Asserts that an object/array parent includes none of the provided child values through
          * reference equality. Returns the parent value if the assertion passes.
@@ -560,18 +498,9 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * assertWrap.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{}`;
-         * assertWrap.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // throws an error
-         * assertWrap.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // throws an error
+         * assertWrap.lacksValues({}, [child, child2]); // returns `{}`;
+         * assertWrap.lacksValues({child, child2}, [child, child2]); // throws an error
+         * assertWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
          * ```
          *
          * @returns The value if the assertion passes.
@@ -580,7 +509,7 @@ export declare const valueGuards: {
          * - {@link assertWrap.lacksValues} : the opposite assertion.
          * - {@link assertWrap.hasValue} : the single-value assertion.
          */
-        lacksValues: typeof autoGuardSymbol;
+        lacksValues<Parent extends object | string>(this: void, parent: Parent, values: unknown[], failureMessage?: string | undefined): Parent;
         /**
          * Asserts that child value is contained within a parent object, array, or string through
          * reference equality. Returns the child value if the assertion passes.
@@ -607,7 +536,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assertWrap.isNotIn} : the opposite assertion.
          */
-        isIn: <const Child, const Parent>(child: Child, parent: Parent, failureMessage?: string | undefined) => NarrowToExpected<Child, Values<Parent>>;
+        isIn<Parent extends object | string, Child>(this: void, child: Child, parent: Parent, failureMessage?: string | undefined): Extract<Child, Values<Parent>>;
         /**
          * Asserts that child value is _not_ contained within a parent object, array, or string
          * through reference equality. Returns the child value if the assertion passes.
@@ -634,7 +563,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assertWrap.isIn} : the opposite assertion.
          */
-        isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, Values<Parent>>;
+        isNotIn<Parent extends object | string, Child>(this: void, child: Child, parent: Parent, failureMessage?: string | undefined): Exclude<Child, Values<Parent>>;
         /**
          * Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays. Returns
          * the value if the assertion passes.
@@ -659,7 +588,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assertWrap.isNotEmpty} : the opposite assertion.
          */
-        isEmpty: <const Actual extends CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => NarrowToActual<Actual, Empty>;
+        isEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToActual<Actual, Empty>;
         /**
          * Asserts that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          * Returns the value if the assertion passes.
@@ -684,7 +613,7 @@ export declare const valueGuards: {
          * @see
          * - {@link assertWrap.isEmpty} : the opposite assertion.
          */
-        isNotEmpty: <const Actual extends CanBeEmpty>(actual: Actual) => Exclude<Actual, Empty>;
+        isNotEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual, failureMessage?: string | undefined): Exclude<Actual, Empty>;
     };
     checkWrap: {
         /**
@@ -708,7 +637,7 @@ export declare const valueGuards: {
          * - {@link checkWrap.lacksValue} : the opposite check.
          * - {@link checkWrap.hasValues} : the multi-value check.
          */
-        hasValue: typeof autoGuardSymbol;
+        hasValue<Parent extends object | string>(this: void, parent: Parent, value: unknown): Parent | undefined;
         /**
          * Checks that an object/array parent does _not_ include a child value through reference
          * equality.
@@ -731,7 +660,7 @@ export declare const valueGuards: {
          * - {@link checkWrap.hasValue} : the opposite check.
          * - {@link checkWrap.lacksValues} : the multi-value check.
          */
-        lacksValue: typeof autoGuardSymbol;
+        lacksValue<Parent extends object | string>(this: void, parent: Parent, value: unknown): Parent | undefined;
         /**
          * Checks that an object/array parent includes all child values through reference equality.
          *
@@ -745,28 +674,16 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * checkWrap.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{child, child2}`
-         * checkWrap.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `undefined`
-         * checkWrap.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // returns `[child]`
+         * checkWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`
+         * checkWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
+         * checkWrap.hasValues([child], [child, child2]); // returns `[child]`
          * ```
          *
          * @see
          * - {@link checkWrap.lacksValues} : the opposite check.
          * - {@link checkWrap.hasValue} : the single-value check.
          */
-        hasValues: typeof autoGuardSymbol;
+        hasValues<Parent extends object | string>(this: void, parent: Parent, values: unknown[]): Parent | undefined;
         /**
          * Checks that an object/array parent includes none of the provided child values through
          * reference equality.
@@ -781,25 +698,16 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * checkWrap.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{}`
-         * checkWrap.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `undefined`
-         * checkWrap.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `undefined`
+         * checkWrap.lacksValues({}, [child, child2]); // returns `{}`
+         * checkWrap.lacksValues({child, child2}, [child, child2]); // returns `undefined`
+         * checkWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
          * ```
          *
          * @see
          * - {@link checkWrap.lacksValues} : the opposite check.
          * - {@link checkWrap.hasValue} : the single-value check.
          */
-        lacksValues: typeof autoGuardSymbol;
+        lacksValues<Parent extends object | string>(this: void, parent: Parent, values: unknown[]): Parent | undefined;
         /**
          * Checks that child value is contained within a parent object, array, or string through
          * reference equality.
@@ -824,7 +732,7 @@ export declare const valueGuards: {
          * @see
          * - {@link checkWrap.isNotIn} : the opposite check.
          */
-        isIn: <const Child, const Parent>(child: Child, parent: Parent) => NarrowToExpected<Child, Values<Parent>> | undefined;
+        isIn<Parent extends object | string, Child>(this: void, child: Child, parent: Parent): Extract<Child, Values<Parent>> | undefined;
         /**
          * Checks that child value is _not_ contained within a parent object, array, or string
          * through reference equality.
@@ -849,7 +757,7 @@ export declare const valueGuards: {
          * @see
          * - {@link checkWrap.isIn} : the opposite check.
          */
-        isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, Values<Parent>> | undefined;
+        isNotIn<Parent extends object | string, Child>(this: void, child: Child, parent: Parent): Exclude<Child, Values<Parent>> | undefined;
         /**
          * Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -871,7 +779,7 @@ export declare const valueGuards: {
          * @see
          * - {@link checkWrap.isNotEmpty} : the opposite check.
          */
-        isEmpty: <const Actual extends CanBeEmpty>(actual: Actual) => NarrowToActual<Actual, Empty> | undefined;
+        isEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual): NarrowToActual<Actual, Empty> | undefined;
         /**
          * Checks that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -893,7 +801,7 @@ export declare const valueGuards: {
          * @see
          * - {@link checkWrap.isEmpty} : the opposite check.
          */
-        isNotEmpty: <const Actual extends CanBeEmpty>(actual: Actual) => Exclude<Actual, Empty> | undefined;
+        isNotEmpty<Actual extends CanBeEmpty>(this: void, actual: Actual): Exclude<Actual, Empty> | undefined;
     };
     waitUntil: {
         /**
@@ -925,7 +833,7 @@ export declare const valueGuards: {
          * - {@link waitUntil.lacksValue} : the opposite assertion.
          * - {@link waitUntil.hasValues} : the multi-value assertion.
          */
-        hasValue: typeof autoGuardSymbol;
+        hasValue: <Parent extends object | string>(this: void, value: unknown, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent>;
         /**
          * Repeatedly calls a callback until its output is an object/array parent does _not_ include
          * a child value through reference equality. Once the callback output passes, it is
@@ -955,7 +863,7 @@ export declare const valueGuards: {
          * - {@link waitUntil.hasValue} : the opposite assertion.
          * - {@link waitUntil.lacksValues} : the multi-value assertion.
          */
-        lacksValue: typeof autoGuardSymbol;
+        lacksValue: <Parent extends object | string>(this: void, value: unknown, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent>;
         /**
          * Repeatedly calls a callback until its output is an object/array parent includes all child
          * values through reference equality. Once the callback output passes, it is returned. If
@@ -971,31 +879,13 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * await waitUntil.hasValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child, child2};
-         *     },
-         * ); // returns `{child, child2}`;
-         * await waitUntil.hasValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child: {a: 'a'}, child2};
-         *     },
-         * ); // throws an error
-         * await waitUntil.hasValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => [child],
-         * ); // returns `[child]`;
+         * await waitUntil.hasValues([child, child2], () => {
+         *     return {child, child2};
+         * }); // returns `{child, child2}`;
+         * await waitUntil.hasValues([child, child2], () => {
+         *     return {child: {a: 'a'}, child2};
+         * }); // throws an error
+         * await waitUntil.hasValues([child, child2], () => [child]); // returns `[child]`;
          * ```
          *
          * @returns The callback output once it passes.
@@ -1004,7 +894,7 @@ export declare const valueGuards: {
          * - {@link waitUntil.lacksValues} : the opposite assertion.
          * - {@link waitUntil.hasValue} : the single-value assertion.
          */
-        hasValues: typeof autoGuardSymbol;
+        hasValues: <Parent extends object | string>(this: void, value: unknown[], callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent>;
         /**
          * Repeatedly calls a callback until its output is an object/array parent includes none of
          * the provided child values through reference equality. Once the callback output passes, it
@@ -1020,33 +910,15 @@ export declare const valueGuards: {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * await waitUntil.lacksValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {};
-         *     },
-         * ); // returns `{}`;
-         * await waitUntil.lacksValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child, child2};
-         *     },
-         * ); // throws an error
-         * await waitUntil.lacksValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child: {a: 'a'}, child2};
-         *     },
-         * ); // throws an error
+         * await waitUntil.lacksValues([child, child2], () => {
+         *     return {};
+         * }); // returns `{}`;
+         * await waitUntil.lacksValues([child, child2], () => {
+         *     return {child, child2};
+         * }); // throws an error
+         * await waitUntil.lacksValues([child, child2], () => {
+         *     return {child: {a: 'a'}, child2};
+         * }); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -1055,7 +927,7 @@ export declare const valueGuards: {
          * - {@link waitUntil.lacksValues} : the opposite assertion.
          * - {@link waitUntil.hasValue} : the single-value assertion.
          */
-        lacksValues: typeof autoGuardSymbol;
+        lacksValues: <Parent extends object | string>(this: void, value: unknown[], callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent>;
         /**
          * Repeatedly calls a callback until its output is child value is contained within a parent
          * object, array, or string through reference equality. Once the callback output passes, it
@@ -1083,7 +955,7 @@ export declare const valueGuards: {
          * @see
          * - {@link waitUntil.isNotIn} : the opposite assertion.
          */
-        isIn: <const Child, const Parent>(parent: Parent, callback: () => MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Child, Values<Parent>>>;
+        isIn: <Child, Parent>(this: void, parent: Parent, callback: () => MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Child, Values<Parent>>>;
         /**
          * Repeatedly calls a callback until its output is child value is _not_ contained within a
          * parent object, array, or string through reference equality. Once the callback output
@@ -1111,7 +983,7 @@ export declare const valueGuards: {
          * @see
          * - {@link waitUntil.isIn} : the opposite assertion.
          */
-        isNotIn: <const Child, const Parent>(parent: Parent, callback: () => MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Child, Values<Parent>>>;
+        isNotIn: <Child, Parent>(this: void, parent: Parent, callback: () => MaybePromise<Child>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Child, Values<Parent>>>;
         /**
          * Repeatedly calls a callback until its output is a value is empty. Supports strings, Maps,
          * Sets, objects, and arrays. Once the callback output passes, it is returned. If the
@@ -1141,7 +1013,7 @@ export declare const valueGuards: {
          * @see
          * - {@link waitUntil.isNotEmpty} : the opposite assertion.
          */
-        isEmpty: <const Actual extends CanBeEmpty>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToActual<Actual, Empty>>;
+        isEmpty: <Actual extends CanBeEmpty>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToActual<Actual, Empty>>;
         /**
          * Repeatedly calls a callback until its output is a value is _not_ empty. Supports strings,
          * Maps, Sets, objects, and arrays. Once the callback output passes, it is returned. If the
@@ -1171,7 +1043,6 @@ export declare const valueGuards: {
          * @see
          * - {@link waitUntil.isEmpty} : the opposite assertion.
          */
-        isNotEmpty: <const Actual extends CanBeEmpty>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Empty>>;
+        isNotEmpty: <Actual extends CanBeEmpty>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Empty>>;
     };
 };
-export {};