@augment-vir/assert 31.0.0 → 31.1.0

package/dist/assertions/runtime-type.js

@@ -1,127 +1,467 @@
 import { stringify, } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../guard-types/guard-override.js';
-function isNotArray(actual, failureMessage) {
-    if (Array.isArray(actual)) {
-        throw new AssertionError(`'${stringify(actual)}' is an array.`, failureMessage);
-    }
-}
-function isNotBigInt(actual, failureMessage) {
-    if (typeof actual === 'bigint') {
-        throw new AssertionError(`'${stringify(actual)}' is a bigint.`, failureMessage);
-    }
-}
-function isNotBoolean(actual, failureMessage) {
-    if (typeof actual === 'boolean') {
-        throw new AssertionError(`'${stringify(actual)}' is a boolean.`, failureMessage);
-    }
-}
-function isNotFunction(actual, failureMessage) {
-    if (typeof actual === 'function') {
-        throw new AssertionError(`'${stringify(actual)}' is a function.`, failureMessage);
-    }
-}
-function isNotNumber(actual, failureMessage) {
-    if (typeof actual === 'number') {
-        throw new AssertionError(`'${stringify(actual)}' is a number.`, failureMessage);
-    }
-}
-function isNotObject(actual, failureMessage) {
-    if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
-        throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
-    }
-}
-function isNotString(actual, failureMessage) {
-    if (typeof actual === 'string') {
-        throw new AssertionError(`'${stringify(actual)}' is a string.`, failureMessage);
-    }
-}
-function isNotSymbol(actual, failureMessage) {
-    if (typeof actual === 'symbol') {
-        throw new AssertionError(`'${stringify(actual)}' is a symbol.`, failureMessage);
-    }
-}
-function isNotUndefined(actual, failureMessage) {
-    if (typeof actual === 'undefined') {
-        throw new AssertionError(`'${stringify(actual)}' is a undefined.`, failureMessage);
-    }
-}
-function isNotNull(actual, failureMessage) {
-    if (actual === null) {
-        throw new AssertionError(`'${stringify(actual)}' is a null.`, failureMessage);
-    }
-}
-function isArray(actual, failureMessage) {
-    if (!Array.isArray(actual)) {
-        throw new AssertionError(`'${stringify(actual)}' is not an array.`, failureMessage);
-    }
-}
-function isBigInt(actual, failureMessage) {
-    if (typeof actual !== 'bigint') {
-        throw new AssertionError(`'${stringify(actual)}' is not a bigint.`, failureMessage);
-    }
-}
-function isBoolean(actual, failureMessage) {
-    if (typeof actual !== 'boolean') {
-        throw new AssertionError(`'${stringify(actual)}' is not a boolean.`, failureMessage);
-    }
-}
-function isFunction(actual, failureMessage) {
-    if (typeof actual !== 'function') {
-        throw new AssertionError(`'${stringify(actual)}' is not a function.`, failureMessage);
-    }
-}
-export function isNumber(actual, failureMessage) {
-    if (typeof actual !== 'number' || isNaN(actual)) {
-        throw new AssertionError(`'${stringify(actual)}' is not a number.`, failureMessage);
-    }
-}
-function isObject(actual, failureMessage) {
-    if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
-        throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
-    }
-}
-function isString(actual, failureMessage) {
-    if (typeof actual !== 'string') {
-        throw new AssertionError(`'${stringify(actual)}' is not a string.`, failureMessage);
-    }
-}
-function isSymbol(actual, failureMessage) {
-    if (typeof actual !== 'symbol') {
-        throw new AssertionError(`'${stringify(actual)}' is not a symbol.`, failureMessage);
-    }
-}
-function isUndefined(actual, failureMessage) {
-    if (typeof actual !== 'undefined') {
-        throw new AssertionError(`'${stringify(actual)}' is not a undefined.`, failureMessage);
-    }
-}
-function isNull(actual, failureMessage) {
-    if (actual !== null) {
-        throw new AssertionError(`'${stringify(actual)}' is not nul.`, failureMessage);
-    }
-}
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
 const assertions = {
-    isArray,
-    isBigInt,
-    isBoolean,
-    isFunction,
-    isNull,
-    isNumber,
-    isObject,
-    isString,
-    isSymbol,
-    isUndefined,
-    isNotArray,
-    isNotBigInt,
-    isNotBoolean,
-    isNotFunction,
-    isNotNull,
-    isNotNumber,
-    isNotObject,
-    isNotString,
-    isNotSymbol,
-    isNotUndefined,
+    /**
+     * Asserts that a value is an array.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isArray([]); // passes
+     * assert.isArray({length: 4}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotArray} : the opposite assertion.
+     */
+    isArray(actual, failureMessage) {
+        if (!Array.isArray(actual)) {
+            throw new AssertionError(`'${stringify(actual)}' is not an array.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a BigInt.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isBigInt(123n); // passes
+     * assert.isBigInt(123); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotBigInt} : the opposite assertion.
+     */
+    isBigInt(actual, failureMessage) {
+        if (typeof actual !== 'bigint') {
+            throw new AssertionError(`'${stringify(actual)}' is not a bigint.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a boolean.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isBoolean(true); // passes
+     * assert.isBoolean('true'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotBoolean} : the opposite assertion.
+     */
+    isBoolean(actual, failureMessage) {
+        if (typeof actual !== 'boolean') {
+            throw new AssertionError(`'${stringify(actual)}' is not a boolean.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a function.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isFunction(() => {}); // passes
+     * assert.isFunction({}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isFunction(actual, failureMessage) {
+        if (typeof actual !== 'function') {
+            throw new AssertionError(`'${stringify(actual)}' is not a function.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is exactly `null`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNull(null); // passes
+     * assert.isNull(undefined); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isNull(actual, failureMessage) {
+        if (actual !== null) {
+            throw new AssertionError(`'${stringify(actual)}' is not nul.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a number. This excludes `NaN`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNumber(123); // passes
+     * assert.isNumber(123n); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isNumber(actual, failureMessage) {
+        if (typeof actual !== 'number' || isNaN(actual)) {
+            throw new AssertionError(`'${stringify(actual)}' is not a number.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is an object. This excludes arrays.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isObject({}); // passes
+     * assert.isObject([]); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isObject(actual, failureMessage) {
+        if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+            throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a string.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isString(''); // passes
+     * assert.isString(5); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isString(actual, failureMessage) {
+        if (typeof actual !== 'string') {
+            throw new AssertionError(`'${stringify(actual)}' is not a string.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a symbol.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isSymbol(Symbol('my-symbol')); // passes
+     * assert.isSymbol('my-symbol'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isSymbol(actual, failureMessage) {
+        if (typeof actual !== 'symbol') {
+            throw new AssertionError(`'${stringify(actual)}' is not a symbol.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is exactly `undefined`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isUndefined(undefined); // passes
+     * assert.isUndefined(null); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isUndefined(actual, failureMessage) {
+        if (typeof actual !== 'undefined') {
+            throw new AssertionError(`'${stringify(actual)}' is not a undefined.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ an array.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotArray([]); // fails
+     * assert.isNotArray({length: 4}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isArray} : the opposite assertion.
+     */
+    isNotArray(actual, failureMessage) {
+        if (Array.isArray(actual)) {
+            throw new AssertionError(`'${stringify(actual)}' is an array.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a BigInt.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotBigInt(123n); // fails
+     * assert.isNotBigInt(123); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isBigInt} : the opposite assertion.
+     */
+    isNotBigInt(actual, failureMessage) {
+        if (typeof actual === 'bigint') {
+            throw new AssertionError(`'${stringify(actual)}' is a bigint.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a boolean.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotBoolean(true); // fails
+     * assert.isNotBoolean('true'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isBoolean} : the opposite assertion.
+     */
+    isNotBoolean(actual, failureMessage) {
+        if (typeof actual === 'boolean') {
+            throw new AssertionError(`'${stringify(actual)}' is a boolean.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a function.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotFunction(() => {}); // fails
+     * assert.isNotFunction({}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotFunction(actual, failureMessage) {
+        if (typeof actual === 'function') {
+            throw new AssertionError(`'${stringify(actual)}' is a function.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ exactly `null`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotNull(null); // fails
+     * assert.isNotNull(undefined); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed. @see
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotNull(actual, failureMessage) {
+        if (actual === null) {
+            throw new AssertionError(`'${stringify(actual)}' is a null.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a number. This includes `NaN`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotNumber(123); // fails
+     * assert.isNotNumber(123n); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isNotFunction} : the opposite assertion.
+     */
+    isNotNumber(actual, failureMessage) {
+        if (typeof actual === 'number') {
+            throw new AssertionError(`'${stringify(actual)}' is a number.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ an object. This includes arrays.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotObject({}); // fails
+     * assert.isNotObject([]); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotObject(actual, failureMessage) {
+        if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+            throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a string.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotString(''); // fails
+     * assert.isNotString(5); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotString(actual, failureMessage) {
+        if (typeof actual === 'string') {
+            throw new AssertionError(`'${stringify(actual)}' is a string.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a symbol.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotSymbol(Symbol('my-symbol')); // fails
+     * assert.isNotSymbol('my-symbol'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotSymbol(actual, failureMessage) {
+        if (typeof actual === 'symbol') {
+            throw new AssertionError(`'${stringify(actual)}' is a symbol.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ exactly `undefined`.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotUndefined(undefined); // fails
+     * assert.isNotUndefined(null); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion failed.
+     * @see
+     * - {@link assert.isFunction} : the opposite assertion.
+     */
+    isNotUndefined(actual, failureMessage) {
+        if (typeof actual === 'undefined') {
+            throw new AssertionError(`'${stringify(actual)}' is a undefined.`, failureMessage);
+        }
+    },
 };
 export const runtimeTypeGuards = {
     assert: assertions,
@@ -143,7 +483,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotArray} : the opposite check.
          */
-        isArray: autoGuard(),
+        isArray(actual) {
+            return Array.isArray(actual);
+        },
         /**
          * Checks that a value is a BigInt.
          *
@@ -161,7 +503,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotBigInt} : the opposite check.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt(actual) {
+            return typeof actual === 'bigint';
+        },
         /**
          * Checks that a value is a boolean.
          *
@@ -179,7 +523,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotBoolean} : the opposite check.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean(actual) {
+            return typeof actual === 'boolean';
+        },
         /**
          * Checks that a value is a function.
          *
@@ -197,7 +543,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isFunction: autoGuard(),
+        isFunction(actual) {
+            return typeof actual === 'function';
+        },
         /**
          * Checks that a value is exactly `null`.
          *
@@ -215,7 +563,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isNull: autoGuardSymbol,
+        isNull(actual) {
+            return actual === null;
+        },
         /**
          * Checks that a value is a number. This excludes `NaN`.
          *
@@ -233,7 +583,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isNumber: autoGuardSymbol,
+        isNumber(actual) {
+            return typeof actual === 'number';
+        },
         /**
          * Checks that a value is an object. This excludes arrays.
          *
@@ -251,7 +603,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isObject: autoGuardSymbol,
+        isObject(actual) {
+            return !Array.isArray(actual) && typeof actual === 'object' && !!actual;
+        },
         /**
          * Checks that a value is a string.
          *
@@ -269,7 +623,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isString: autoGuardSymbol,
+        isString(actual) {
+            return typeof actual === 'string';
+        },
         /**
          * Checks that a value is a symbol.
          *
@@ -287,7 +643,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isSymbol: autoGuardSymbol,
+        isSymbol(actual) {
+            return typeof actual === 'symbol';
+        },
         /**
          * Checks that a value is exactly `undefined`.
          *
@@ -305,7 +663,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isUndefined: autoGuardSymbol,
+        isUndefined(actual) {
+            return actual === undefined;
+        },
         /**
          * Checks that a value is _not_ an array.
          *
@@ -323,7 +683,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isArray} : the opposite check.
          */
-        isNotArray: autoGuard(),
+        isNotArray(actual) {
+            return !Array.isArray(actual);
+        },
         /**
          * Checks that a value is _not_ a BigInt.
          *
@@ -341,7 +703,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isBigInt} : the opposite check.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt(actual) {
+            return typeof actual !== 'bigint';
+        },
         /**
          * Checks that a value is _not_ a boolean.
          *
@@ -359,7 +723,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isBoolean} : the opposite check.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean(actual) {
+            return typeof actual !== 'boolean';
+        },
         /**
          * Checks that a value is _not_ a function.
          *
@@ -377,7 +743,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction(actual) {
+            return typeof actual !== 'function';
+        },
         /**
          * Checks that a value is _not_ exactly `null`.
          *
@@ -395,7 +763,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotNull: autoGuard(),
+        isNotNull(actual) {
+            return actual !== null;
+        },
         /**
          * Checks that a value is _not_ a number. This includes `NaN`.
          *
@@ -413,7 +783,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber(actual) {
+            return typeof actual !== 'number';
+        },
         /**
          * Checks that a value is _not_ an object. This includes arrays.
          *
@@ -431,7 +803,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotObject: autoGuard(),
+        isNotObject(actual) {
+            return Array.isArray(actual) || typeof actual !== 'object' || !actual;
+        },
         /**
          * Checks that a value is _not_ a string.
          *
@@ -449,7 +823,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotString: autoGuard(),
+        isNotString(actual) {
+            return typeof actual !== 'string';
+        },
         /**
          * Checks that a value is _not_ a symbol.
          *
@@ -467,7 +843,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotSymbol: autoGuard(),
+        isNotSymbol(actual) {
+            return typeof actual !== 'symbol';
+        },
         /**
          * Checks that a value is _not_ exactly `undefined`.
          *
@@ -485,7 +863,9 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link check.isFunction} : the opposite check.
          */
-        isNotUndefined: autoGuard(),
+        isNotUndefined(actual) {
+            return typeof actual !== 'undefined';
+        },
     },
     assertWrap: {
         /**
@@ -507,7 +887,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotArray} : the opposite assertion.
          */
-        isArray: autoGuard(),
+        isArray(actual, failureMessage) {
+            if (!Array.isArray(actual)) {
+                throw new AssertionError(`'${stringify(actual)}' is not an array.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a BigInt. Returns the value if the assertion passes.
          *
@@ -527,7 +912,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotBigInt} : the opposite assertion.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt(actual, failureMessage) {
+            if (typeof actual !== 'bigint') {
+                throw new AssertionError(`'${stringify(actual)}' is not a bigint.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a boolean. Returns the value if the assertion passes.
          *
@@ -547,7 +937,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotBoolean} : the opposite assertion.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean(actual, failureMessage) {
+            if (typeof actual !== 'boolean') {
+                throw new AssertionError(`'${stringify(actual)}' is not a boolean.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a function. Returns the value if the assertion passes.
          *
@@ -567,7 +962,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isFunction: autoGuard(),
+        isFunction(actual, failureMessage) {
+            if (typeof actual !== 'function') {
+                throw new AssertionError(`'${stringify(actual)}' is not a function.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is exactly `null. Returns the value if the assertion passes.
          *
@@ -587,7 +987,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isNull: autoGuardSymbol,
+        isNull(actual, failureMessage) {
+            if (actual !== null) {
+                throw new AssertionError(`'${stringify(actual)}' is not nul.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a number. This excludes `NaN. Returns the value if the assertion
          * passes.
@@ -608,7 +1013,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isNumber: autoGuardSymbol,
+        isNumber(actual, failureMessage) {
+            if (typeof actual !== 'number' || isNaN(actual)) {
+                throw new AssertionError(`'${stringify(actual)}' is not a number.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is an object. This excludes arrays. Returns the value if the
          * assertion passes.
@@ -629,7 +1039,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isObject: autoGuardSymbol,
+        isObject(actual, failureMessage) {
+            if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+                throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a string. Returns the value if the assertion passes.
          *
@@ -649,7 +1064,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isString: autoGuardSymbol,
+        isString(actual, failureMessage) {
+            if (typeof actual !== 'string') {
+                throw new AssertionError(`'${stringify(actual)}' is not a string.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Trying to assign a unique symbol to another variable kills the `unique` part of the
          * symbol. this seems to be a bug with TypeScript itself.
@@ -678,7 +1098,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isSymbol: autoGuard(),
+        isSymbol(actual, failureMessage) {
+            if (typeof actual !== 'symbol') {
+                throw new AssertionError(`'${stringify(actual)}' is not a symbol.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is exactly `undefined. Returns the value if the assertion passes.
          *
@@ -698,7 +1123,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isUndefined: autoGuardSymbol,
+        isUndefined(actual, failureMessage) {
+            if (typeof actual !== 'undefined') {
+                throw new AssertionError(`'${stringify(actual)}' is not a undefined.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ an array. Returns the value if the assertion passes.
          *
@@ -718,7 +1148,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isArray} : the opposite assertion.
          */
-        isNotArray: autoGuard(),
+        isNotArray(actual, failureMessage) {
+            if (Array.isArray(actual)) {
+                throw new AssertionError(`'${stringify(actual)}' is an array.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a BigInt. Returns the value if the assertion passes.
          *
@@ -738,7 +1173,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isBigInt} : the opposite assertion.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt(actual, failureMessage) {
+            if (typeof actual === 'bigint') {
+                throw new AssertionError(`'${stringify(actual)}' is a bigint.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a boolean. Returns the value if the assertion passes.
          *
@@ -758,7 +1198,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isBoolean} : the opposite assertion.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean(actual, failureMessage) {
+            if (typeof actual === 'boolean') {
+                throw new AssertionError(`'${stringify(actual)}' is a boolean.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a function. Returns the value if the assertion passes.
          *
@@ -778,7 +1223,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction(actual, failureMessage) {
+            if (typeof actual === 'function') {
+                throw new AssertionError(`'${stringify(actual)}' is a function.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ exactly `null. Returns the value if the assertion passes.
          *
@@ -798,7 +1248,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotNull: autoGuard(),
+        isNotNull(actual, failureMessage) {
+            if (actual === null) {
+                throw new AssertionError(`'${stringify(actual)}' is a null.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a number. This includes `NaN. Returns the value if the
          * assertion passes.
@@ -819,7 +1274,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isNotFunction} : the opposite assertion.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber(actual, failureMessage) {
+            if (typeof actual === 'number') {
+                throw new AssertionError(`'${stringify(actual)}' is a number.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ an object. This includes arrays. Returns the value if the
          * assertion passes.
@@ -840,7 +1300,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotObject: autoGuard(),
+        isNotObject(actual, failureMessage) {
+            if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+                throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a string. Returns the value if the assertion passes.
          *
@@ -860,7 +1325,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotString: autoGuard(),
+        isNotString(actual, failureMessage) {
+            if (typeof actual === 'string') {
+                throw new AssertionError(`'${stringify(actual)}' is a string.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a symbol. Returns the value if the assertion passes.
          *
@@ -880,7 +1350,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotSymbol: autoGuard(),
+        isNotSymbol(actual, failureMessage) {
+            if (typeof actual === 'symbol') {
+                throw new AssertionError(`'${stringify(actual)}' is a symbol.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ exactly `undefined. Returns the value if the assertion
          * passes.
@@ -901,7 +1376,12 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link assertWrap.isFunction} : the opposite assertion.
          */
-        isNotUndefined: autoGuard(),
+        isNotUndefined(actual, failureMessage) {
+            if (typeof actual === 'undefined') {
+                throw new AssertionError(`'${stringify(actual)}' is a undefined.`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -923,7 +1403,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotArray} : the opposite check.
          */
-        isArray: autoGuard(),
+        isArray(actual) {
+            if (Array.isArray(actual)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a BigInt. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -943,7 +1430,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotBigInt} : the opposite check.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt(actual) {
+            if (typeof actual === 'bigint') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a boolean. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -963,7 +1457,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotBoolean} : the opposite check.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean(actual) {
+            if (typeof actual === 'boolean') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a function. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -983,7 +1484,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isFunction: autoGuard(),
+        isFunction(actual) {
+            if (typeof actual === 'function') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is exactly `null. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1003,7 +1511,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isNull: autoGuardSymbol,
+        isNull(actual) {
+            if (actual === null) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a number. This excludes `NaN. Returns the value if the check
          * passes, otherwise `undefined`.
@@ -1023,7 +1538,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isNumber: autoGuardSymbol,
+        isNumber(actual) {
+            if (typeof actual === 'number') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is an object. This excludes arrays. Returns the value if the check
          * passes, otherwise `undefined`.
@@ -1043,7 +1565,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isObject: autoGuardSymbol,
+        isObject(actual) {
+            if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1063,7 +1592,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isString: autoGuardSymbol,
+        isString(actual) {
+            if (typeof actual === 'string') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a symbol. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1083,32 +1619,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isSymbol: autoGuardSymbol,
-        /**
-         * It doesn't make any sense for `checkWrap.isUndefined` to exist. If the input is
-         * `undefined`, it returns `undefined`. If the input isn't `undefined`, it still returns
-         * `undefined`.
-         */
-        /**
-         * Checks that a value is exactly `undefined. Returns the value if the check passes,
-         * otherwise `undefined`.
-         *
-         * Type guards the value.
-         *
-         * @example
-         *
-         * ```ts
-         * import {checkWrap} from '@augment-vir/assert';
-         *
-         * checkWrap.isUndefined(undefined); // returns `undefined`
-         * checkWrap.isUndefined(null); // returns `undefined`
-         * ```
-         *
-         * @returns The value if the check passes. Otherwise, `undefined`.
-         * @see
-         * - {@link checkWrap.isNotFunction} : the opposite check.
-         */
-        isUndefined: undefined,
+        isSymbol(actual) {
+            if (typeof actual === 'symbol') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ an array. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1128,7 +1646,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isArray} : the opposite check.
          */
-        isNotArray: autoGuard(),
+        isNotArray(actual) {
+            if (Array.isArray(actual)) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a BigInt. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1148,7 +1673,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isBigInt} : the opposite check.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt(actual) {
+            if (typeof actual === 'bigint') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a boolean. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1168,7 +1700,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isBoolean} : the opposite check.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean(actual) {
+            if (typeof actual === 'boolean') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a function. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1188,7 +1727,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction(actual) {
+            if (typeof actual === 'function') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ exactly `null. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -1208,7 +1754,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotNull: autoGuard(),
+        isNotNull(actual) {
+            if (actual === null) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a number. This includes `NaN. Returns the value if the check
          * passes, otherwise `undefined`.
@@ -1228,7 +1781,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isNotFunction} : the opposite check.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber(actual) {
+            if (typeof actual === 'number') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ an object. This includes arrays. Returns the value if the
          * check passes, otherwise `undefined`.
@@ -1248,7 +1808,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotObject: autoGuard(),
+        isNotObject(actual) {
+            if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ a string. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1268,7 +1835,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotString: autoGuard(),
+        isNotString(actual) {
+            if (typeof actual === 'string') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that a value is _not_ a symbol. Returns the value if the check passes, otherwise
          * `undefined`.
@@ -1288,12 +1862,14 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link checkWrap.isFunction} : the opposite check.
          */
-        isNotSymbol: autoGuard(),
-        /**
-         * It doesn't make any sense for `checkWrap.isNotUndefined` to exist. If the input is not
-         * `undefined`, then it still returns `undefined`.
-         */
-        isNotUndefined: undefined,
+        isNotSymbol(actual) {
+            if (typeof actual === 'symbol') {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -1317,7 +1893,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotArray} : the opposite assertion.
          */
-        isArray: autoGuard(),
+        isArray: createWaitUntil(assertions.isArray),
         /**
          * Repeatedly calls a callback until its output is a BigInt. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1337,7 +1913,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotBigInt} : the opposite assertion.
          */
-        isBigInt: autoGuardSymbol,
+        isBigInt: createWaitUntil(assertions.isBigInt),
         /**
          * Repeatedly calls a callback until its output is a boolean. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1357,7 +1933,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotBoolean} : the opposite assertion.
          */
-        isBoolean: autoGuardSymbol,
+        isBoolean: createWaitUntil(assertions.isBoolean),
         /**
          * Repeatedly calls a callback until its output is a function. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1381,7 +1957,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isFunction: autoGuard(),
+        isFunction: createWaitUntil(assertions.isFunction),
         /**
          * Repeatedly calls a callback until its output is exactly `null`. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1401,7 +1977,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isNull: autoGuardSymbol,
+        isNull: createWaitUntil(assertions.isNull),
         /**
          * Repeatedly calls a callback until its output is a number. This excludes `NaN`. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1421,7 +1997,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isNumber: autoGuardSymbol,
+        isNumber: createWaitUntil(assertions.isNumber),
         /**
          * Repeatedly calls a callback until its output is an object. This excludes arrays. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1443,7 +2019,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isObject: autoGuardSymbol,
+        isObject: createWaitUntil(assertions.isObject),
         /**
          * Repeatedly calls a callback until its output is a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1463,7 +2039,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isString: autoGuardSymbol,
+        isString: createWaitUntil(assertions.isString),
         /**
          * Repeatedly calls a callback until its output is a symbol. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1483,7 +2059,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isSymbol: autoGuardSymbol,
+        isSymbol: createWaitUntil(assertions.isSymbol),
         /**
          * Repeatedly calls a callback until its output is exactly `undefined`. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1503,7 +2079,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isUndefined: autoGuardSymbol,
+        isUndefined: createWaitUntil(assertions.isUndefined),
         /**
          * Repeatedly calls a callback until its output is _not_ an array. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1525,7 +2101,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isArray} : the opposite assertion.
          */
-        isNotArray: autoGuard(),
+        isNotArray: createWaitUntil(assertions.isNotArray),
         /**
          * Repeatedly calls a callback until its output is _not_ a BigInt. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1545,7 +2121,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isBigInt} : the opposite assertion.
          */
-        isNotBigInt: autoGuard(),
+        isNotBigInt: createWaitUntil(assertions.isNotBigInt),
         /**
          * Repeatedly calls a callback until its output is _not_ a boolean. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1565,7 +2141,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isBoolean} : the opposite assertion.
          */
-        isNotBoolean: autoGuard(),
+        isNotBoolean: createWaitUntil(assertions.isNotBoolean),
         /**
          * Repeatedly calls a callback until its output is _not_ a function. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1589,7 +2165,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotFunction: autoGuard(),
+        isNotFunction: createWaitUntil(assertions.isNotFunction),
         /**
          * Repeatedly calls a callback until its output is _not_ exactly `null`. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1609,7 +2185,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotNull: autoGuard(),
+        isNotNull: createWaitUntil(assertions.isNotNull),
         /**
          * Repeatedly calls a callback until its output is _not_ a number. This includes `NaN`. Once
          * the callback output passes, it is returned. If the attempts time out, an error is
@@ -1630,7 +2206,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isNotFunction} : the opposite assertion.
          */
-        isNotNumber: autoGuard(),
+        isNotNumber: createWaitUntil(assertions.isNotNumber),
         /**
          * Repeatedly calls a callback until its output is _not_ an object. This includes arrays.
          * Once the callback output passes, it is returned. If the attempts time out, an error is
@@ -1653,7 +2229,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotObject: autoGuard(),
+        isNotObject: createWaitUntil(assertions.isNotObject),
         /**
          * Repeatedly calls a callback until its output is _not_ a string. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1673,7 +2249,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotString: autoGuard(),
+        isNotString: createWaitUntil(assertions.isNotString),
         /**
          * Repeatedly calls a callback until its output is _not_ a symbol. Once the callback output
          * passes, it is returned. If the attempts time out, an error is thrown.
@@ -1693,7 +2269,7 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotSymbol: autoGuard(),
+        isNotSymbol: createWaitUntil(assertions.isNotSymbol),
         /**
          * Repeatedly calls a callback until its output is _not_ exactly `undefined`. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -1713,6 +2289,6 @@ export const runtimeTypeGuards = {
          * @see
          * - {@link waitUntil.isFunction} : the opposite assertion.
          */
-        isNotUndefined: autoGuard(),
+        isNotUndefined: createWaitUntil(assertions.isNotUndefined),
     },
 };