@augment-vir/assert 30.0.0 → 30.0.2

package/dist/assertions/numeric.d.ts

@@ -1,3 +1,4 @@
+import { autoGuardSymbol } from '../guard-types/guard-override.js';
 declare function isAbove(actual: number, expected: number, failureMessage?: string | undefined): void;
 declare function isAtLeast(actual: number, expected: number, failureMessage?: string | undefined): void;
 declare function isBelow(actual: number, expected: number, failureMessage?: string | undefined): void;
@@ -8,62 +9,1015 @@ declare function isInfinite(actual: number, failureMessage?: string | undefined)
 declare function isApproximately(actual: number, expected: number, delta: number, failureMessage?: string | undefined): void;
 declare function isNotApproximately(actual: number, expected: number, delta: number, failureMessage?: string | undefined): void;
 export declare const numericGuards: {
-    assertions: {
+    assert: {
         /**
-         * Check if a number is above the expectation (`actual > expected`).
+         * Asserts that a number is above the expectation (`actual > expected`).
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isAbove(10, 5); // passes
+         * assert.isAbove(5, 5); // fails
+         * assert.isAbove(5, 10); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isBelow} : the opposite assertion.
+         * - {@link assert.isAtLeast} : the more lenient assertion.
          */
         isAbove: typeof isAbove;
         /**
-         * Check if a number is at least the expectation (`actual >= expected`).
+         * Asserts that a number is at least the expectation (`actual >= expected`).
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isAtLeast(10, 5); // passes
+         * assert.isAtLeast(5, 5); // passes
+         * assert.isAtLeast(5, 10); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isAtMost} : the opposite assertion.
+         * - {@link assert.isAbove} : the more restrictive assertion.
          */
         isAtLeast: typeof isAtLeast;
         /**
-         * Check if a number is below the expectation (`actual < expected`).
+         * Asserts that a number is below the expectation (`actual < expected`).
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isBelow(10, 5); // fails
+         * assert.isBelow(5, 5); // fails
+         * assert.isBelow(5, 10); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isAbove} : the opposite assertion.
+         * - {@link assert.isAtMost} : the more lenient assertion.
          */
         isBelow: typeof isBelow;
         /**
-         * Check if a number is at most the expectation (`actual <= expected`).
+         * Asserts that a number is at most the expectation (`actual <= expected`).
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isAtMost(10, 5); // fails
+         * assert.isAtMost(5, 5); // passes
+         * assert.isAtMost(5, 10); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isAtLeast} : the opposite assertion.
+         * - {@link assert.isBelow} : the more restrictive assertion.
          */
         isAtMost: typeof isAtMost;
         /**
-         * Check if a number is
-         * [`NaN`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+         * Asserts that a number is
+         * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isNaN(10); // fails
+         * assert.isNaN(parseInt('invalid')); // passes
+         * assert.isNaN(Infinity); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isNumber} : can be used as the opposite assertion.
          */
         isNaN: typeof isNaNGuard;
         /**
-         * Check if a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
+         * Asserts that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isFinite(10); // passes
+         * assert.isFinite(parseInt('invalid')); // fails
+         * assert.isFinite(Infinity); // fails
+         * assert.isFinite(-Infinity); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isNaN} : an opposite assertion.
+         * - {@link assert.isInfinite} : an opposite assertion.
          */
         isFinite: typeof isFiniteGuard;
         /**
-         * Check if a number is either `Infinity` or `-Infinity`.
+         * Asserts that a number is either `Infinity` or `-Infinity`.
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isInfinite(10); // fails
+         * assert.isInfinite(parseInt('invalid')); // fails
+         * assert.isInfinite(Infinity); // passes
+         * assert.isInfinite(-Infinity); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isNaN} : an opposite assertion.
+         * - {@link assert.isInfinite} : an opposite assertion.
          */
         isInfinite: typeof isInfinite;
         /**
-         * Check if a number is with ±`delta` of the expectation.
+         * Asserts that a number is within ±`delta` of the expectation.
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isApproximately(10, 8, 4); // passes
+         * assert.isApproximately(10, 12, 4); // passes
+         * assert.isApproximately(10, 8, 1); // fails
+         * assert.isApproximately(10, 12, 1); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isNotApproximately} : the opposite assertion.
          */
         isApproximately: typeof isApproximately;
         /**
-         * Check if a number is outside ±`delta` of the expectation.
+         * Asserts that a number is outside ±`delta` of the expectation.
          *
          * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.isNotApproximately(10, 8, 4); // fails
+         * assert.isNotApproximately(10, 12, 4); // fails
+         * assert.isNotApproximately(10, 8, 1); // passes
+         * assert.isNotApproximately(10, 12, 1); // passes
+         * ```
+         *
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assert.isApproximately} : the opposite assertion.
          */
         isNotApproximately: typeof isNotApproximately;
     };
+    check: {
+        /**
+         * Checks that a number is above the expectation (`actual > expected`).
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isAbove(10, 5); // returns `true`
+         * check.isAbove(5, 5); // returns `false`
+         * check.isAbove(5, 10); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isBelow} : the opposite check.
+         * - {@link check.isAtLeast} : the more lenient check.
+         */
+        isAbove: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is at least the expectation (`actual >= expected`).
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isAtLeast(10, 5); // returns `true`
+         * check.isAtLeast(5, 5); // returns `true`
+         * check.isAtLeast(5, 10); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isAtMost} : the opposite check.
+         * - {@link check.isAbove} : the more restrictive check.
+         */
+        isAtLeast: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is below the expectation (`actual < expected`).
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isBelow(10, 5); // returns `false`
+         * check.isBelow(5, 5); // returns `false`
+         * check.isBelow(5, 10); // returns `true`
+         * ```
+         *
+         * @see
+         * - {@link check.isAbove} : the opposite check.
+         * - {@link check.isAtMost} : the more lenient check.
+         */
+        isBelow: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is at most the expectation (`actual <= expected`).
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isAtMost(10, 5); // returns `false`
+         * check.isAtMost(5, 5); // returns `true`
+         * check.isAtMost(5, 10); // returns `true`
+         * ```
+         *
+         * @see
+         * - {@link check.isAtLeast} : the opposite check.
+         * - {@link check.isBelow} : the more restrictive check.
+         */
+        isAtMost: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is
+         * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isNaN(10); // returns `false`
+         * check.isNaN(parseInt('invalid')); // returns `true`
+         * check.isNaN(Infinity); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isNumber} : can be used as the opposite check.
+         */
+        isNaN: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isFinite(10); // returns `true`
+         * check.isFinite(parseInt('invalid')); // returns `false`
+         * check.isFinite(Infinity); // returns `false`
+         * check.isFinite(-Infinity); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isNaN} : an opposite check.
+         * - {@link check.isInfinite} : an opposite check.
+         */
+        isFinite: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is either `Infinity` or `-Infinity`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isInfinite(10); // returns `false`
+         * check.isInfinite(parseInt('invalid')); // returns `false`
+         * check.isInfinite(Infinity); // returns `true`
+         * check.isInfinite(-Infinity); // returns `true`
+         * ```
+         *
+         * @see
+         * - {@link check.isNaN} : an opposite check.
+         * - {@link check.isInfinite} : an opposite check.
+         */
+        isInfinite: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is within ±`delta` of the expectation.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isApproximately(10, 8, 4); // returns `true`
+         * check.isApproximately(10, 12, 4); // returns `true`
+         * check.isApproximately(10, 8, 1); // returns `false`
+         * check.isApproximately(10, 12, 1); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.isNotApproximately} : the opposite check.
+         */
+        isApproximately: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is outside ±`delta` of the expectation.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.isNotApproximately(10, 8, 4); // returns `false`
+         * check.isNotApproximately(10, 12, 4); // returns `false`
+         * check.isNotApproximately(10, 8, 1); // returns `true`
+         * check.isNotApproximately(10, 12, 1); // returns `true`
+         * ```
+         *
+         * @see
+         * - {@link check.isApproximately} : the opposite check.
+         */
+        isNotApproximately: typeof autoGuardSymbol;
+    };
+    assertWrap: {
+        /**
+         * Asserts that a number is above the expectation (`actual > expected`). Returns the number
+         * if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isAbove(10, 5); // returns `10`
+         * assertWrap.isAbove(5, 5); // throws an error
+         * assertWrap.isAbove(5, 10); // throws an error
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isBelow} : the opposite assertion.
+         * - {@link assertWrap.isAtLeast} : the more lenient assertion.
+         */
+        isAbove: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is at least the expectation (`actual >= expected`). Returns the
+         * number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isAtLeast(10, 5); // returns `10`
+         * assertWrap.isAtLeast(5, 5); // returns `5`
+         * assertWrap.isAtLeast(5, 10); // throws an error
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isAtMost} : the opposite assertion.
+         * - {@link assertWrap.isAbove} : the more restrictive assertion.
+         */
+        isAtLeast: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is below the expectation (`actual < expected`). Returns the number
+         * if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isBelow(10, 5); // throws an error
+         * assertWrap.isBelow(5, 5); // throws an error
+         * assertWrap.isBelow(5, 10); // returns `5`
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isAbove} : the opposite assertion.
+         * - {@link assertWrap.isAtMost} : the more lenient assertion.
+         */
+        isBelow: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is at most the expectation (`actual <= expected`). Returns the
+         * number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isAtMost(10, 5); // throws an error
+         * assertWrap.isAtMost(5, 5); // returns `5`
+         * assertWrap.isAtMost(5, 10); // returns `5`
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isAtLeast} : the opposite assertion.
+         * - {@link assertWrap.isBelow} : the more restrictive assertion.
+         */
+        isAtMost: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is
+         * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+         * Returns the number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isNaN(10); // throws an error
+         * assertWrap.isNaN(parseInt('invalid')); // returns `NaN`
+         * assertWrap.isNaN(Infinity); // throws an error
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isNumber} : can be used as the opposite assertion.
+         */
+        isNaN: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
+         * Returns the number if the assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isFinite(10); // returns `10`
+         * assertWrap.isFinite(parseInt('invalid')); // throws an error
+         * assertWrap.isFinite(Infinity); // throws an error
+         * assertWrap.isFinite(-Infinity); // throws an error
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isNaN} : an opposite assertion.
+         * - {@link assertWrap.isInfinite} : an opposite assertion.
+         */
+        isFinite: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is either `Infinity` or `-Infinity`. Returns the number if the
+         * assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isInfinite(10); // throws an error
+         * assertWrap.isInfinite(parseInt('invalid')); // throws an error
+         * assertWrap.isInfinite(Infinity); // returns `Infinity`
+         * assertWrap.isInfinite(-Infinity); // returns `-Infinity`
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isNaN} : an opposite assertion.
+         * - {@link assertWrap.isInfinite} : an opposite assertion.
+         */
+        isInfinite: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is within ±`delta` of the expectation. Returns the number if the
+         * assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isApproximately(10, 8, 4); // returns `10`
+         * assertWrap.isApproximately(10, 12, 4); // returns `10`
+         * assertWrap.isApproximately(10, 8, 1); // throws an error
+         * assertWrap.isApproximately(10, 12, 1); // throws an error
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isNotApproximately} : the opposite assertion.
+         */
+        isApproximately: typeof autoGuardSymbol;
+        /**
+         * Asserts that a number is outside ±`delta` of the expectation. Returns the number if the
+         * assertion passes.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.isNotApproximately(10, 8, 4); // throws an error
+         * assertWrap.isNotApproximately(10, 12, 4); // throws an error
+         * assertWrap.isNotApproximately(10, 8, 1); // returns `10`
+         * assertWrap.isNotApproximately(10, 12, 1); // returns `10`
+         * ```
+         *
+         * @returns The value if the assertion passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link assertWrap.isApproximately} : the opposite assertion.
+         */
+        isNotApproximately: typeof autoGuardSymbol;
+    };
+    checkWrap: {
+        /**
+         * Checks that a number is above the expectation (`actual > expected`). Returns the number
+         * if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isAbove(10, 5); // returns `10`
+         * checkWrap.isAbove(5, 5); // returns `undefined`
+         * checkWrap.isAbove(5, 10); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isBelow} : the opposite check.
+         * - {@link checkWrap.isAtLeast} : the more lenient check.
+         */
+        isAbove: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is at least the expectation (`actual >= expected`). Returns the
+         * number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isAtLeast(10, 5); // returns `10`
+         * checkWrap.isAtLeast(5, 5); // returns `5`
+         * checkWrap.isAtLeast(5, 10); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isAtMost} : the opposite check.
+         * - {@link checkWrap.isAbove} : the more restrictive check.
+         */
+        isAtLeast: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is below the expectation (`actual < expected`). Returns the number
+         * if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isBelow(10, 5); // returns `undefined`
+         * checkWrap.isBelow(5, 5); // returns `undefined`
+         * checkWrap.isBelow(5, 10); // returns `5`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isAbove} : the opposite check.
+         * - {@link checkWrap.isAtMost} : the more lenient check.
+         */
+        isBelow: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is at most the expectation (`actual <= expected`). Returns the
+         * number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isAtMost(10, 5); // returns `undefined`
+         * checkWrap.isAtMost(5, 5); // returns `5`
+         * checkWrap.isAtMost(5, 10); // returns `5`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isAtLeast} : the opposite check.
+         * - {@link checkWrap.isBelow} : the more restrictive check.
+         */
+        isAtMost: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is
+         * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+         * Returns the number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isNaN(10); // returns `undefined`
+         * checkWrap.isNaN(parseInt('invalid')); // returns `NaN`
+         * checkWrap.isNaN(Infinity); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isNumber} : can be used as the opposite check.
+         */
+        isNaN: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is finite: meaning, not `NaN` and not `Infinity` or `-Infinity`.
+         * Returns the number if the check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isFinite(10); // returns `10`
+         * checkWrap.isFinite(parseInt('invalid')); // returns `undefined`
+         * checkWrap.isFinite(Infinity); // returns `undefined`
+         * checkWrap.isFinite(-Infinity); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isNaN} : an opposite check.
+         * - {@link checkWrap.isInfinite} : an opposite check.
+         */
+        isFinite: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is either `Infinity` or `-Infinity`. Returns the number if the check
+         * passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isInfinite(10); // returns `undefined`
+         * checkWrap.isInfinite(parseInt('invalid')); // returns `undefined`
+         * checkWrap.isInfinite(Infinity); // returns `Infinity`
+         * checkWrap.isInfinite(-Infinity); // returns `-Infinity`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isNaN} : an opposite check.
+         * - {@link checkWrap.isInfinite} : an opposite check.
+         */
+        isInfinite: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is within ±`delta` of the expectation. Returns the number if the
+         * check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isApproximately(10, 8, 4); // returns `10`
+         * checkWrap.isApproximately(10, 12, 4); // returns `10`
+         * checkWrap.isApproximately(10, 8, 1); // returns `undefined`
+         * checkWrap.isApproximately(10, 12, 1); // returns `undefined`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isNotApproximately} : the opposite check.
+         */
+        isApproximately: typeof autoGuardSymbol;
+        /**
+         * Checks that a number is outside ±`delta` of the expectation. Returns the number if the
+         * check passes, otherwise `undefined`.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.isNotApproximately(10, 8, 4); // returns `undefined`
+         * checkWrap.isNotApproximately(10, 12, 4); // returns `undefined`
+         * checkWrap.isNotApproximately(10, 8, 1); // returns `10`
+         * checkWrap.isNotApproximately(10, 12, 1); // returns `10`
+         * ```
+         *
+         * @returns The value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.isApproximately} : the opposite check.
+         */
+        isNotApproximately: typeof autoGuardSymbol;
+    };
+    waitUntil: {
+        /**
+         * Repeatedly calls a callback until its output is a number that is above the expectation
+         * (`actual > expected`). Once the callback output passes, it is returned. If the attempts
+         * time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isAbove(5, () => 10); // returns `10`
+         * await waitUntil.isAbove(5, () => 5); // throws an error
+         * await waitUntil.isAbove(10, () => 5); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.isBelow} : the opposite assertion.
+         * - {@link waitUntil.isAtLeast} : the more lenient assertion.
+         */
+        isAbove: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is at least the expectation
+         * (`actual >= expected`). Once the callback output passes, it is returned. If the attempts
+         * time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isAtLeast(5, () => 10); // returns `10`
+         * await waitUntil.isAtLeast(5, () => 5); // returns `5`
+         * await waitUntil.isAtLeast(10, () => 5); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.isAtMost} : the opposite assertion.
+         * - {@link waitUntil.isAbove} : the more restrictive assertion.
+         */
+        isAtLeast: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is below the expectation
+         * (`actual < expected`). Once the callback output passes, it is returned. If the attempts
+         * time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isBelow(5, () => 10); // throws an error
+         * await waitUntil.isBelow(5, () => 5); // throws an error
+         * await waitUntil.isBelow(10, () => 5); // returns `5`
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.isAbove} : the opposite assertion.
+         * - {@link waitUntil.isAtMost} : the more lenient assertion.
+         */
+        isBelow: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is at most the expectation
+         * (`actual <= expected`). Once the callback output passes, it is returned. If the attempts
+         * time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isAtMost(5, () => 10); // throws an error
+         * await waitUntil.isAtMost(5, () => 5); // returns `5`
+         * await waitUntil.isAtMost(10, () => 5); // returns `5`
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.isAtLeast} : the opposite assertion.
+         * - {@link waitUntil.isBelow} : the more restrictive assertion.
+         */
+        isAtMost: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is
+         * [`NaN`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/NaN).
+         * Once the callback output passes, it is returned. If the attempts time out, an error is
+         * thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isNaN(() => 10); // throws an error
+         * await waitUntil.isNaN(() => parseInt('invalid')); // returns `NaN`
+         * await waitUntil.isNaN(() => Infinity); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isNumber} : can be used as the opposite assertion.
+         */
+        isNaN: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is finite: meaning, not
+         * `NaN` and not `Infinity` or `-Infinity`. Once the callback output passes, it is returned.
+         * If the attempts time out, an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isFinite(() => 10); // returns `10`
+         * await waitUntil.isFinite(() => parseInt('invalid')); // throws an error
+         * await waitUntil.isFinite(() => Infinity); // throws an error
+         * await waitUntil.isFinite(() => -Infinity); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isNaN} : an opposite assertion.
+         * - {@link waitUntil.isInfinite} : an opposite assertion.
+         */
+        isFinite: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is either `Infinity` or
+         * `-Infinity`. Once the callback output passes, it is returned. If the attempts time out,
+         * an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isInfinite(() => 10); // throws an error
+         * await waitUntil.isInfinite(() => parseInt('invalid')); // throws an error
+         * await waitUntil.isInfinite(() => Infinity); // returns `Infinity`
+         * await waitUntil.isInfinite(() => -Infinity); // returns `-Infinity`
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isNaN} : an opposite assertion.
+         * - {@link waitUntil.isInfinite} : an opposite assertion.
+         */
+        isInfinite: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is within ±`delta` of the
+         * expectation. Once the callback output passes, it is returned. If the attempts time out,
+         * an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isApproximately(8, 4, () => 10); // returns `10`
+         * await waitUntil.isApproximately(12, 4, () => 10); // returns `10`
+         * await waitUntil.isApproximately(8, 1, () => 10); // throws an error
+         * await waitUntil.isApproximately(12, 1, () => 10); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isNotApproximately} : the opposite assertion.
+         */
+        isApproximately: typeof autoGuardSymbol;
+        /**
+         * Repeatedly calls a callback until its output is a number that is outside ±`delta` of the
+         * expectation. Once the callback output passes, it is returned. If the attempts time out,
+         * an error is thrown.
+         *
+         * Performs no type guarding.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.isNotApproximately(8, 4, () => 10); // throws an error
+         * await waitUntil.isNotApproximately(12, 4, () => 10); // throws an error
+         * await waitUntil.isNotApproximately(8, 1, () => 10); // returns `10`
+         * await waitUntil.isNotApproximately(12, 1, () => 10); // returns `10`
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} If the assertion fails.
+         * @see
+         * - {@link waitUntil.isApproximately} : the opposite assertion.
+         */
+        isNotApproximately: typeof autoGuardSymbol;
+    };
 };
 export {};