@augment-vir/assert 30.8.4 → 31.0.1

package/dist/assertions/primitive.js

@@ -1,45 +1,119 @@
 import { stringify } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../guard-types/guard-override.js';
-/** Asserts that the given value is a primitive. */
-function isPrimitive(input, failureMessage) {
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
+const assertions = {
     /**
-     * `null` is a primitive but `typeof null` gives `'object'` so we have to special case `null`
-     * here.
+     * Asserts that a value is a valid `PropertyKey`. `PropertyKey` is a built-in TypeScript type
+     * which refers to all possible key types for a JavaScript object.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isPropertyKey('key'); // passes
+     * assert.isPropertyKey(true); // fails
+     * assert.isPropertyKey({}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotPropertyKey} : the opposite assertion.
      */
-    if (input !== null && (typeof input === 'object' || typeof input === 'function')) {
-        throw new AssertionError(`'${stringify(input)}' is not a Primitive.`, failureMessage);
-    }
-}
-function isNotPrimitive(input, failureMessage) {
-    try {
-        isPrimitive(input);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`'${stringify(input)}' is a Primitive.`, failureMessage);
-}
-/** Asserts that the given value is a PropertyKey ( string | number | symbol). */
-function isPropertyKey(input, failureMessage) {
-    if (typeof input !== 'string' && typeof input !== 'number' && typeof input !== 'symbol') {
-        throw new AssertionError(`'${stringify(input)}' is not a PropertyKey.`, failureMessage);
-    }
-}
-function isNotPropertyKey(input, failureMessage) {
-    try {
-        isPropertyKey(input);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`'${stringify(input)}' is a PropertyKey.`, failureMessage);
-}
-const assertions = {
-    isPropertyKey,
-    isNotPropertyKey,
-    isPrimitive,
-    isNotPrimitive,
+    isPropertyKey(actual, failureMessage) {
+        if (typeof actual !== 'string' &&
+            typeof actual !== 'number' &&
+            typeof actual !== 'symbol') {
+            throw new AssertionError(`'${stringify(actual)}' is not a PropertyKey.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a valid `PropertyKey`. `PropertyKey` is a built-in TypeScript
+     * type which refers to all possible key types for a JavaScript object.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotPropertyKey('key'); // fails
+     * assert.isNotPropertyKey(true); // passes
+     * assert.isNotPropertyKey({}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isPropertyKey} : the opposite assertion.
+     */
+    isNotPropertyKey(actual, failureMessage) {
+        if (typeof actual === 'string' ||
+            typeof actual === 'number' ||
+            typeof actual === 'symbol') {
+            throw new AssertionError(`'${stringify(actual)}' is a PropertyKey.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is a JavaScript
+     * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive).
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isPrimitive('key'); // passes
+     * assert.isPrimitive(true); // passes
+     * assert.isPrimitive({}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotPrimitive} : the opposite assertion.
+     */
+    isPrimitive(actual, failureMessage) {
+        /**
+         * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+         * `null` here.
+         */
+        if (actual !== null && (typeof actual === 'object' || typeof actual === 'function')) {
+            throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is _not_ a JavaScript
+     * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive).
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isPrimitive('key'); // fails
+     * assert.isPrimitive(true); // fails
+     * assert.isPrimitive({}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isPrimitive} : the opposite assertion.
+     */
+    isNotPrimitive(actual, failureMessage) {
+        /**
+         * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+         * `null` here.
+         */
+        if (actual === null || (typeof actual !== 'object' && typeof actual !== 'function')) {
+            throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
+        }
+    },
 };
 export const primitiveGuards = {
     assert: assertions,
@@ -55,15 +129,21 @@ export const primitiveGuards = {
          * ```ts
          * import {check} from '@augment-vir/assert';
          *
-         * check.isPropertyKey('key'); // returns `true`
-         * check.isPropertyKey(true); // returns `false`
-         * check.isPropertyKey({}); // returns `false`
+         * check.isNotPrimitive('key'); // returns `false`
+         * check.isNotPrimitive(true); // returns `false`
+         * check.isNotPrimitive({}); // returns `true`
          * ```
          *
          * @see
-         * - {@link check.isNotPropertyKey} : the opposite check.
+         * - {@link check.isPrimitive} : the opposite check.
          */
-        isNotPrimitive: autoGuard(),
+        isNotPrimitive(actual) {
+            /**
+             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+             * `null` here.
+             */
+            return actual !== null && (typeof actual === 'object' || typeof actual === 'function');
+        },
         /**
          * Checks that a value is _not_ a valid `PropertyKey`. `PropertyKey` is a built-in
          * TypeScript type which refers to all possible key types for a JavaScript object.
@@ -83,7 +163,11 @@ export const primitiveGuards = {
          * @see
          * - {@link check.isPropertyKey} : the opposite check.
          */
-        isNotPropertyKey: autoGuard(),
+        isNotPropertyKey(actual) {
+            return (typeof actual !== 'string' &&
+                typeof actual !== 'number' &&
+                typeof actual !== 'symbol');
+        },
         /**
          * Checks that a value is a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive).
@@ -103,7 +187,13 @@ export const primitiveGuards = {
          * @see
          * - {@link check.isNotPrimitive} : the opposite check.
          */
-        isPrimitive: autoGuardSymbol,
+        isPrimitive(actual) {
+            /**
+             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+             * `null` here.
+             */
+            return actual === null || (typeof actual !== 'object' && typeof actual !== 'function');
+        },
         /**
          * Checks that a value is _not_ a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive).
@@ -115,15 +205,19 @@ export const primitiveGuards = {
          * ```ts
          * import {check} from '@augment-vir/assert';
          *
-         * check.isPrimitive('key'); // returns `false`
-         * check.isPrimitive(true); // returns `false`
-         * check.isPrimitive({}); // returns `true`
+         * check.isPropertyKey('key'); // returns `true`
+         * check.isPropertyKey(true); // returns `false`
+         * check.isPropertyKey({}); // returns `false`
          * ```
          *
          * @see
-         * - {@link check.isPrimitive} : the opposite check.
+         * - {@link check.isNotPropertyKey} : the opposite check.
          */
-        isPropertyKey: autoGuardSymbol,
+        isPropertyKey(actual) {
+            return (typeof actual === 'string' ||
+                typeof actual === 'number' ||
+                typeof actual === 'symbol');
+        },
     },
     assertWrap: {
         /**
@@ -148,7 +242,16 @@ export const primitiveGuards = {
          * @see
          * - {@link assertWrap.isNotPropertyKey} : the opposite assertion.
          */
-        isNotPrimitive: autoGuard(),
+        isNotPrimitive(actual, failureMessage) {
+            /**
+             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+             * `null` here.
+             */
+            if (actual === null || (typeof actual !== 'object' && typeof actual !== 'function')) {
+                throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a valid `PropertyKey`. `PropertyKey` is a built-in
          * TypeScript type which refers to all possible key types for a JavaScript object. Returns
@@ -171,7 +274,14 @@ export const primitiveGuards = {
          * @see
          * - {@link assertWrap.isPropertyKey} : the opposite assertion.
          */
-        isNotPropertyKey: autoGuard(),
+        isNotPropertyKey(actual, failureMessage) {
+            if (typeof actual === 'string' ||
+                typeof actual === 'number' ||
+                typeof actual === 'symbol') {
+                throw new AssertionError(`'${stringify(actual)}' is a PropertyKey.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive). Returns the value if
@@ -194,7 +304,16 @@ export const primitiveGuards = {
          * @see
          * - {@link assertWrap.isNotPrimitive} : the opposite assertion.
          */
-        isPrimitive: autoGuardSymbol,
+        isPrimitive(actual, failureMessage) {
+            /**
+             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+             * `null` here.
+             */
+            if (actual !== null && (typeof actual === 'object' || typeof actual === 'function')) {
+                throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
+            }
+            return actual;
+        },
         /**
          * Asserts that a value is _not_ a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive). Returns the value if
@@ -217,7 +336,14 @@ export const primitiveGuards = {
          * @see
          * - {@link assertWrap.isPrimitive} : the opposite assertion.
          */
-        isPropertyKey: autoGuardSymbol,
+        isPropertyKey(actual, failureMessage) {
+            if (typeof actual !== 'string' &&
+                typeof actual !== 'number' &&
+                typeof actual !== 'symbol') {
+                throw new AssertionError(`'${stringify(actual)}' is not a PropertyKey.`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -232,16 +358,27 @@ export const primitiveGuards = {
          * ```ts
          * import {checkWrap} from '@augment-vir/assert';
          *
-         * checkWrap.isPropertyKey('key'); // returns `'key'`
-         * checkWrap.isPropertyKey(true); // returns `undefined`
-         * checkWrap.isPropertyKey({}); // returns `undefined`
+         * checkWrap.isNotPrimitive('key'); // returns `undefined`
+         * checkWrap.isNotPrimitive(true); // returns `undefined`
+         * checkWrap.isNotPrimitive({}); // returns `{}`
          * ```
          *
          * @returns The value if the check passes, otherwise `undefined`.
          * @see
-         * - {@link checkWrap.isNotPropertyKey} : the opposite check.
+         * - {@link checkWrap.isPrimitive} : the opposite check.
          */
-        isNotPrimitive: autoGuard(),
+        isNotPrimitive(actual) {
+            /**
+             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+             * `null` here.
+             */
+            if (actual !== null && (typeof actual === 'object' || typeof actual === 'function')) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ a valid `PropertyKey`. `PropertyKey` is a built-in
          * TypeScript type which refers to all possible key types for a JavaScript object. Returns
@@ -263,7 +400,16 @@ export const primitiveGuards = {
          * @see
          * - {@link checkWrap.isPropertyKey} : the opposite check.
          */
-        isNotPropertyKey: autoGuard(),
+        isNotPropertyKey(actual) {
+            if (typeof actual !== 'string' &&
+                typeof actual !== 'number' &&
+                typeof actual !== 'symbol') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive). Returns the value if
@@ -285,7 +431,18 @@ export const primitiveGuards = {
          * @see
          * - {@link checkWrap.isNotPrimitive} : the opposite check.
          */
-        isPrimitive: autoGuardSymbol,
+        isPrimitive(actual) {
+            /**
+             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
+             * `null` here.
+             */
+            if (actual === null || (typeof actual !== 'object' && typeof actual !== 'function')) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that a value is _not_ a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive). Returns the value if
@@ -307,7 +464,16 @@ export const primitiveGuards = {
          * @see
          * - {@link checkWrap.isPrimitive} : the opposite check.
          */
-        isPropertyKey: autoGuardSymbol,
+        isPropertyKey(actual) {
+            if (typeof actual === 'string' ||
+                typeof actual === 'number' ||
+                typeof actual === 'symbol') {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -333,7 +499,7 @@ export const primitiveGuards = {
          * @see
          * - {@link waitUntil.isNotPropertyKey} : the opposite assertion.
          */
-        isNotPrimitive: autoGuard(),
+        isNotPrimitive: createWaitUntil(assertions.isNotPrimitive),
         /**
          * Repeatedly calls a callback until its output is _not_ a valid `PropertyKey`.
          * `PropertyKey` is a built-in TypeScript type which refers to all possible key types for a
@@ -357,7 +523,7 @@ export const primitiveGuards = {
          * @see
          * - {@link waitUntil.isPropertyKey} : the opposite assertion.
          */
-        isNotPropertyKey: autoGuard(),
+        isNotPropertyKey: createWaitUntil(assertions.isNotPropertyKey),
         /**
          * Repeatedly calls a callback until its output is a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive). Once the callback
@@ -380,7 +546,7 @@ export const primitiveGuards = {
          * @see
          * - {@link waitUntil.isNotPrimitive} : the opposite assertion.
          */
-        isPrimitive: autoGuardSymbol,
+        isPrimitive: createWaitUntil(assertions.isPrimitive),
         /**
          * Repeatedly calls a callback until its output is _not_ a JavaScript
          * [primitive](https://developer.mozilla.org/docs/Glossary/Primitive). Once the callback
@@ -403,6 +569,6 @@ export const primitiveGuards = {
          * @see
          * - {@link waitUntil.isPrimitive} : the opposite assertion.
          */
-        isPropertyKey: autoGuardSymbol,
+        isPropertyKey: createWaitUntil(assertions.isPropertyKey),
     },
 };

package/dist/assertions/promise.d.ts

@@ -1,13 +1,4 @@
-import { autoGuardSymbol } from '../guard-types/guard-override.js';
 import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
-declare function isPromiseLike(actual: unknown, failureMessage?: string | undefined): asserts actual is PromiseLike<any>;
-declare function isNotPromiseLike<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, PromiseLike<any>>;
-/**
- * Checks if a value is an actual `Promise` object. In reality this is just a simple wrapper for
- * `instanceof Promise`, but it makes checking a bit more ergonomic.
- */
-declare function isPromise(actual: unknown, failureMessage?: string | undefined): asserts actual is Promise<any>;
-declare function isNotPromise<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, Promise<any>>;
 export declare const promiseGuards: {
     assert: {
         /**
@@ -42,7 +33,7 @@ export declare const promiseGuards: {
          * - {@link assert.isNotPromiseLike} : the opposite assertion.
          * - {@link assert.isPromise} : the more precise assertion.
          */
-        isPromiseLike: typeof isPromiseLike;
+        isPromiseLike(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is PromiseLike<any>;
         /**
          * Asserts that a value is _not_ a `PromiseLike`.
          *
@@ -75,7 +66,7 @@ export declare const promiseGuards: {
          * - {@link assert.isPromiseLike} : the opposite assertion.
          * - {@link assert.isNotPromise} : the more precise assertion.
          */
-        isNotPromiseLike: typeof isNotPromiseLike;
+        isNotPromiseLike<const Actual>(this: void, actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, PromiseLike<any>>;
         /**
          * Asserts that a value is a `Promise` instance.
          *
@@ -104,7 +95,7 @@ export declare const promiseGuards: {
          * - {@link assert.isNotPromise} : the opposite assertion.
          * - {@link assert.isPromiseLike} : the more lenient assertion.
          */
-        isPromise: typeof isPromise;
+        isPromise(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is Promise<any>;
         /**
          * Asserts that a value is a _not_ `Promise` instance.
          *
@@ -133,7 +124,7 @@ export declare const promiseGuards: {
          * - {@link assert.isPromise} : the opposite assertion.
          * - {@link assert.isNotPromiseLike} : the more lenient assertion.
          */
-        isNotPromise: typeof isNotPromise;
+        isNotPromise<const Actual>(this: void, actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, Promise<any>>;
     };
     check: {
         /**
@@ -169,7 +160,7 @@ export declare const promiseGuards: {
          * - {@link check.isNotPromiseLike} : the opposite check.
          * - {@link check.isPromise} : the more precise check.
          */
-        isPromiseLike: typeof autoGuardSymbol;
+        isPromiseLike<Actual>(this: void, actual: Actual): actual is Extract<Actual, PromiseLike<any>>;
         /**
          * Checks that a value is _not_ a `PromiseLike`.
          *
@@ -203,7 +194,7 @@ export declare const promiseGuards: {
          * - {@link check.isPromiseLike} : the opposite check.
          * - {@link check.isNotPromise} : the more precise check.
          */
-        isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, PromiseLike<any>>;
+        isNotPromiseLike<const Actual>(this: void, actual: Actual): actual is Exclude<Actual, PromiseLike<any>>;
         /**
          * Checks that a value is a `Promise` instance.
          *
@@ -233,7 +224,7 @@ export declare const promiseGuards: {
          * - {@link check.isNotPromise} : the opposite check.
          * - {@link check.isPromiseLike} : the more lenient check.
          */
-        isPromise: typeof autoGuardSymbol;
+        isPromise<Actual>(this: void, actual: Actual): actual is Extract<Actual, Promise<any>>;
         /**
          * Checks that a value is a _not_ `Promise` instance.
          *
@@ -263,7 +254,7 @@ export declare const promiseGuards: {
          * - {@link check.isPromise} : the opposite check.
          * - {@link check.isNotPromiseLike} : the more lenient check.
          */
-        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
+        isNotPromise<Actual>(this: void, actual: Actual): actual is Exclude<Actual, Promise<any>>;
     };
     assertWrap: {
         /**
@@ -301,7 +292,7 @@ export declare const promiseGuards: {
          * - {@link assertWrap.isNotPromiseLike} : the opposite assertion.
          * - {@link assertWrap.isPromise} : the more precise assertion.
          */
-        isPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, PromiseLike<any>>;
+        isPromiseLike<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): Extract<Actual, PromiseLike<any>>;
         /**
          * Asserts that a value is _not_ a `PromiseLike`. Returns the value if the assertion passes.
          *
@@ -337,7 +328,7 @@ export declare const promiseGuards: {
          * - {@link assertWrap.isPromiseLike} : the opposite assertion.
          * - {@link assertWrap.isNotPromise} : the more precise assertion.
          */
-        isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, PromiseLike<any>>;
+        isNotPromiseLike<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): Exclude<Actual, PromiseLike<any>>;
         /**
          * Asserts that a value is a `Promise` instance. Returns the value if the assertion passes.
          *
@@ -369,7 +360,7 @@ export declare const promiseGuards: {
          * - {@link assertWrap.isNotPromise} : the opposite assertion.
          * - {@link assertWrap.isPromiseLike} : the more lenient assertion.
          */
-        isPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, Promise<any>>;
+        isPromise<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): Extract<Actual, Promise<any>>;
         /**
          * Asserts that a value is a _not_ `Promise` instance. Returns the value if the assertion
          * passes.
@@ -402,7 +393,7 @@ export declare const promiseGuards: {
          * - {@link assertWrap.isPromise} : the opposite assertion.
          * - {@link assertWrap.isNotPromiseLike} : the more lenient assertion.
          */
-        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>>;
+        isNotPromise<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): Exclude<Actual, Promise<any>>;
     };
     checkWrap: {
         /**
@@ -439,7 +430,7 @@ export declare const promiseGuards: {
          * - {@link checkWrap.isNotPromiseLike} : the opposite check.
          * - {@link checkWrap.isPromise} : the more precise check.
          */
-        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>> | undefined;
+        isPromiseLike<Actual>(this: void, actual: Actual): Extract<Actual, PromiseLike<any>> | undefined;
         /**
          * Checks that a value is _not_ a `PromiseLike`. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -474,7 +465,7 @@ export declare const promiseGuards: {
          * - {@link checkWrap.isPromiseLike} : the opposite check.
          * - {@link checkWrap.isNotPromise} : the more precise check.
          */
-        isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, PromiseLike<any>> | undefined;
+        isNotPromiseLike<Actual>(this: void, actual: Actual): Exclude<Actual, PromiseLike<any>> | undefined;
         /**
          * Checks that a value is a `Promise` instance. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -505,7 +496,7 @@ export declare const promiseGuards: {
          * - {@link checkWrap.isNotPromise} : the opposite check.
          * - {@link checkWrap.isPromiseLike} : the more lenient check.
          */
-        isPromise: typeof autoGuardSymbol;
+        isPromise<Actual>(this: void, actual: Actual): Extract<Actual, Promise<any>> | undefined;
         /**
          * Checks that a value is a _not_ `Promise` instance. Returns the value if the check passes,
          * otherwise `undefined`.
@@ -536,7 +527,7 @@ export declare const promiseGuards: {
          * - {@link checkWrap.isPromise} : the opposite check.
          * - {@link checkWrap.isNotPromiseLike} : the more lenient check.
          */
-        isPromiseLike: typeof autoGuardSymbol;
+        isNotPromise<Actual>(this: void, actual: Actual): Exclude<Actual, Promise<any>> | undefined;
     };
     waitUntil: {
         /**
@@ -575,7 +566,7 @@ export declare const promiseGuards: {
          * - {@link waitUntil.isNotPromiseLike} : the opposite assertion.
          * - {@link waitUntil.isPromise} : the more precise assertion.
          */
-        isPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, PromiseLike<any>>>;
+        isPromiseLike: <const Actual>(this: void, callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, PromiseLike<any>>>;
         /**
          * Repeatedly calls a callback until its output is _not_ a `PromiseLike`. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -612,7 +603,7 @@ export declare const promiseGuards: {
          * - {@link waitUntil.isPromiseLike} : the opposite assertion.
          * - {@link waitUntil.isNotPromise} : the more precise assertion.
          */
-        isNotPromiseLike: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PromiseLike<any>>>;
+        isNotPromiseLike: <const Actual>(this: void, callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PromiseLike<any>>>;
         /**
          * Repeatedly calls a callback until its output is a `Promise` instance. Once the callback
          * output passes, it is returned. If the attempts time out, an error is thrown.
@@ -645,7 +636,7 @@ export declare const promiseGuards: {
          * - {@link waitUntil.isNotPromise} : the opposite assertion.
          * - {@link waitUntil.isPromiseLike} : the more lenient assertion.
          */
-        isPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, Promise<any>>>;
+        isPromise: <const Actual>(this: void, callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, Promise<any>>>;
         /**
          * Repeatedly calls a callback until its output is a _not_ `Promise` instance. Once the
          * callback output passes, it is returned. If the attempts time out, an error is thrown.
@@ -678,7 +669,6 @@ export declare const promiseGuards: {
          * - {@link waitUntil.isPromise} : the opposite assertion.
          * - {@link waitUntil.isNotPromiseLike} : the more lenient assertion.
          */
-        isNotPromise: <const Actual>(callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
+        isNotPromise: <const Actual>(this: void, callback: () => Actual, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
     };
 };
-export {};