@augment-vir/assert 31.0.0 → 31.0.1

package/dist/assertions/equality/simple-equality.js

@@ -1,45 +1,204 @@
 import { stringify } from '@augment-vir/core';
 import deepEqual from 'deep-eql';
 import { AssertionError } from '../../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../../guard-types/guard-override.js';
-export function strictEquals(actual, expected, failureMessage) {
-    if (actual !== expected) {
-        throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not strictly equal\n\n${stringify(expected)}\n\n`, failureMessage);
-    }
-}
-function notStrictEquals(actual, expected, failureMessage) {
-    if (actual === expected) {
-        throw new AssertionError(`\n\n${stringify(actual)}\n\nstrictly equals\n\n${stringify(expected)}\n\n`, failureMessage);
-    }
-}
-function looseEquals(actual, expected, failureMessage) {
-    if (actual != expected) {
-        throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not loosely equal\n\n${stringify(expected)}\n\n`, failureMessage);
-    }
-}
-function notLooseEquals(actual, expected, failureMessage) {
-    if (actual == expected) {
-        throw new AssertionError(`\n\n${stringify(actual)}\n\nloosely equals\n\n${stringify(expected)}\n\n`, failureMessage);
-    }
-}
-export function deepEquals(actual, expected, failureMessage) {
-    if (!deepEqual(actual, expected)) {
-        throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not deeply equal\n\n${stringify(expected)}\n\n`, failureMessage);
-    }
-}
-function notDeepEquals(actual, expected, failureMessage) {
-    if (deepEqual(actual, expected)) {
-        throw new AssertionError(`\n\n${stringify(actual)}\n\ndeeply equals\n\n${stringify(expected)}\n\n`, failureMessage);
-    }
-}
+import { createWaitUntil } from '../../guard-types/wait-until-function.js';
 const assertions = {
-    strictEquals,
-    notStrictEquals,
-    looseEquals,
-    notLooseEquals,
-    deepEquals,
-    notDeepEquals,
+    /**
+     * Asserts that two values are strictly equal (using
+     * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using)).
+     *
+     * Type guards the first value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.strictEquals('a', 'a'); // passes
+     *
+     * assert.strictEquals('1', 1); // fails
+     *
+     * assert.strictEquals({a: 'a'}, {a: 'a'}); // fails
+     *
+     * const objectExample = {a: 'a'};
+     * assert.strictEquals(objectExample, objectExample); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are not strictly equal.
+     * @see
+     * - {@link assert.notStrictEquals} : the opposite assertion.
+     * - {@link assert.looseEquals} : the loose equality assertion.
+     */
+    strictEquals(actual, expected, failureMessage) {
+        if (actual !== expected) {
+            throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not strictly equal\n\n${stringify(expected)}\n\n`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that two values are _not_ strictly equal (using
+     * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using)).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.notStrictEquals('a', 'a'); // fails
+     *
+     * assert.notStrictEquals('1', 1); // passes
+     *
+     * assert.notStrictEquals({a: 'a'}, {a: 'a'}); // passes
+     *
+     * const objectExample = {a: 'a'};
+     * assert.notStrictEquals(objectExample, objectExample); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are strictly equal.
+     * @see
+     * - {@link assert.strictEquals} : the opposite assertion.
+     * - {@link assert.notLooseEquals} : the loose equality assertion.
+     */
+    notStrictEquals(actual, expected, failureMessage) {
+        if (actual === expected) {
+            throw new AssertionError(`\n\n${stringify(actual)}\n\nstrictly equals\n\n${stringify(expected)}\n\n`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that two values are loosely equal (using
+     * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
+     *
+     * Type guards the first value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.looseEquals('a', 'a'); // passes
+     *
+     * assert.looseEquals('1', 1); // passes
+     *
+     * assert.looseEquals({a: 'a'}, {a: 'a'}); // fails
+     *
+     * const objectExample = {a: 'a'};
+     * assert.looseEquals(objectExample, objectExample); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are not loosely equal.
+     * @see
+     * - {@link assert.notLooseEquals} : the opposite assertion.
+     * - {@link assert.strictEquals} : the strict equality assertion.
+     */
+    looseEquals(actual, expected, failureMessage) {
+        if (actual != expected) {
+            throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not loosely equal\n\n${stringify(expected)}\n\n`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that two values are _not_ loosely equal (using
+     * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.notLooseEquals('a', 'a'); // fails
+     *
+     * assert.notLooseEquals('1', 1); // fails
+     *
+     * assert.notLooseEquals({a: 'a'}, {a: 'a'}); // passes
+     *
+     * const objectExample = {a: 'a'};
+     * assert.notLooseEquals(objectExample, objectExample); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are loosely equal.
+     * @see
+     * - {@link assert.looseEquals} : the opposite assertion.
+     * - {@link assert.strictEquals} : the strict equality assertion.
+     */
+    notLooseEquals(actual, expected, failureMessage) {
+        if (actual == expected) {
+            throw new AssertionError(`\n\n${stringify(actual)}\n\nloosely equals\n\n${stringify(expected)}\n\n`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that two values are deeply equal using the
+     * [deep-eql](https://www.npmjs.com/package/deep-eql) package.
+     *
+     * Note that this check may be _expensive_, depending on what values it is passed. Whenever
+     * possible, use simpler equality checks instead (see the **see** section below).
+     *
+     * Type guards the first value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.deepEquals('a', 'a'); // passes
+     *
+     * assert.deepEquals('1', 1); // fails
+     *
+     * assert.deepEquals({a: 'a'}, {a: 'a'}); // passes
+     *
+     * const objectExample = {a: 'a'};
+     * assert.deepEquals(objectExample, objectExample); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are not deeply equal.
+     * @see
+     * - {@link assert.notDeepEquals} : the opposite assertion.
+     * - {@link assert.entriesEqual} : a less expensive (but less thorough) deep equality assertion.
+     * - {@link assert.jsonEquals} : a less expensive (but less thorough) deep equality assertion.
+     */
+    deepEquals(actual, expected, failureMessage) {
+        if (!deepEqual(actual, expected)) {
+            throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not deeply equal\n\n${stringify(expected)}\n\n`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that two values are _not_ deeply equal using the
+     * [deep-eql](https://www.npmjs.com/package/deep-eql) package.
+     *
+     * Note that this check may be _expensive_, depending on what values it is passed. Whenever
+     * possible, use simpler equality checks instead (see the **see** section below).
+     *
+     * Type guards the first value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.notDeepEquals('a', 'a'); // false
+     *
+     * assert.notDeepEquals('1', 1); // passes
+     *
+     * assert.notDeepEquals({a: 'a'}, {a: 'a'}); // fails
+     *
+     * const objectExample = {a: 'a'};
+     * assert.notDeepEquals(objectExample, objectExample); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If both inputs are deeply equal.
+     * @see
+     * - {@link assert.deepEquals} : the opposite assertion.
+     * - {@link assert.notEntriesEqual} : a less expensive (but less thorough) deep equality assertion.
+     * - {@link assert.notJsonEquals} : a less expensive (but less thorough) deep equality assertion.
+     */
+    notDeepEquals(actual, expected, failureMessage) {
+        if (deepEqual(actual, expected)) {
+            throw new AssertionError(`\n\n${stringify(actual)}\n\ndeeply equals\n\n${stringify(expected)}\n\n`, failureMessage);
+        }
+    },
 };
+export const deepEquals = assertions.deepEquals;
 export const simpleEqualityGuards = {
     assert: assertions,
     check: {
@@ -68,7 +227,9 @@ export const simpleEqualityGuards = {
          * - {@link check.notStrictEquals} : the opposite check.
          * - {@link check.looseEquals} : the loose equality check.
          */
-        strictEquals: autoGuard(),
+        strictEquals(actual, expected) {
+            return actual === expected;
+        },
         /**
          * Checks that two values are _not_ strictly equal (using
          * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using)).
@@ -94,7 +255,9 @@ export const simpleEqualityGuards = {
          * - {@link check.strictEquals} : the opposite check.
          * - {@link check.notLooseEquals} : the loose equality check.
          */
-        notStrictEquals: autoGuardSymbol,
+        notStrictEquals(actual, expected) {
+            return actual !== expected;
+        },
         /**
          * Checks that two values are loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
@@ -120,7 +283,9 @@ export const simpleEqualityGuards = {
          * - {@link check.notLooseEquals} : the opposite check.
          * - {@link check.strictEquals} : the strict equality check.
          */
-        looseEquals: autoGuardSymbol,
+        looseEquals(actual, expected) {
+            return actual == expected;
+        },
         /**
          * Checks that two values are _not_ loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
@@ -146,7 +311,9 @@ export const simpleEqualityGuards = {
          * - {@link check.looseEquals} : the opposite check.
          * - {@link check.strictEquals} : the strict equality check.
          */
-        notLooseEquals: autoGuardSymbol,
+        notLooseEquals(actual, expected) {
+            return actual != expected;
+        },
         /**
          * Checks that two values are deeply equal using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package.
@@ -176,7 +343,9 @@ export const simpleEqualityGuards = {
          * - {@link check.entriesEqual} : a less expensive (but less thorough) deep equality check.
          * - {@link check.jsonEquals} : a less expensive (but less thorough) deep equality check.
          */
-        deepEquals: autoGuard(),
+        deepEquals(actual, expected) {
+            return deepEqual(actual, expected);
+        },
         /**
          * Checks that two values are _not_ deeply equal using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package.
@@ -206,7 +375,9 @@ export const simpleEqualityGuards = {
          * - {@link check.entriesEqual} : a less expensive (but less thorough) deep equality check.
          * - {@link check.jsonEquals} : a less expensive (but less thorough) deep equality check.
          */
-        notDeepEquals: autoGuardSymbol,
+        notDeepEquals(actual, expected) {
+            return !deepEqual(actual, expected);
+        },
     },
     assertWrap: {
         /**
@@ -236,7 +407,14 @@ export const simpleEqualityGuards = {
          * - {@link assertWrap.notStrictEquals} : the opposite assertion.
          * - {@link assertWrap.looseEquals} : the loose equality assertion.
          */
-        strictEquals: autoGuard(),
+        strictEquals(actual, expected, failureMessage) {
+            if (actual === expected) {
+                return actual;
+            }
+            else {
+                throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not strictly equal\n\n${stringify(expected)}\n\n`, failureMessage);
+            }
+        },
         /**
          * Asserts that two values are _not_ strictly equal (using
          * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using)).
@@ -264,7 +442,14 @@ export const simpleEqualityGuards = {
          * - {@link assertWrap.strictEquals} : the opposite assertion.
          * - {@link assertWrap.notLooseEquals} : the loose equality assertion.
          */
-        notStrictEquals: autoGuardSymbol,
+        notStrictEquals(actual, expected, failureMessage) {
+            if (actual === expected) {
+                throw new AssertionError(`\n\n${stringify(actual)}\n\nstrictly equals\n\n${stringify(expected)}\n\n`, failureMessage);
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Asserts that two values are loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
@@ -292,7 +477,14 @@ export const simpleEqualityGuards = {
          * - {@link assertWrap.notLooseEquals} : the opposite assertion.
          * - {@link assertWrap.strictEquals} : the strict equality assertion.
          */
-        looseEquals: autoGuardSymbol,
+        looseEquals(actual, expected, failureMessage) {
+            if (actual == expected) {
+                return actual;
+            }
+            else {
+                throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not loosely equal\n\n${stringify(expected)}\n\n`, failureMessage);
+            }
+        },
         /**
          * Asserts that two values are _not_ loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
@@ -320,7 +512,14 @@ export const simpleEqualityGuards = {
          * - {@link assertWrap.looseEquals} : the opposite assertion.
          * - {@link assertWrap.strictEquals} : the strict equality assertion.
          */
-        notLooseEquals: autoGuardSymbol,
+        notLooseEquals(actual, expected, failureMessage) {
+            if (actual == expected) {
+                throw new AssertionError(`\n\n${stringify(actual)}\n\nloosely equals\n\n${stringify(expected)}\n\n`, failureMessage);
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Asserts that two values are deeply equal using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package. Returns the first value if
@@ -352,7 +551,14 @@ export const simpleEqualityGuards = {
          * - {@link assertWrap.entriesEqual} : a less expensive (but less thorough) deep equality assertion.
          * - {@link assertWrap.jsonEquals} : a less expensive (but less thorough) deep equality assertion.
          */
-        deepEquals: autoGuard(),
+        deepEquals(actual, expected, failureMessage) {
+            if (deepEqual(actual, expected)) {
+                return actual;
+            }
+            else {
+                throw new AssertionError(`\n\n${stringify(actual)}\n\ndoes not deeply equal\n\n${stringify(expected)}\n\n`, failureMessage);
+            }
+        },
         /**
          * Asserts that two values are _not_ deeply equal using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package. Returns the first value if
@@ -384,7 +590,14 @@ export const simpleEqualityGuards = {
          * - {@link assertWrap.entriesEqual} : a less expensive (but less thorough) deep equality assertion.
          * - {@link assertWrap.jsonEquals} : a less expensive (but less thorough) deep equality assertion.
          */
-        notDeepEquals: autoGuardSymbol,
+        notDeepEquals(actual, expected, failureMessage) {
+            if (deepEqual(actual, expected)) {
+                throw new AssertionError(`\n\n${stringify(actual)}\n\ndeeply equals\n\n${stringify(expected)}\n\n`, failureMessage);
+            }
+            else {
+                return actual;
+            }
+        },
     },
     checkWrap: {
         /**
@@ -414,7 +627,14 @@ export const simpleEqualityGuards = {
          * - {@link checkWrap.notStrictEquals} : the opposite check.
          * - {@link checkWrap.looseEquals} : the loose equality check.
          */
-        strictEquals: autoGuard(),
+        strictEquals(actual, expected) {
+            if (actual === expected) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that two values are _not_ strictly equal (using
          * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using)).
@@ -442,7 +662,14 @@ export const simpleEqualityGuards = {
          * - {@link checkWrap.strictEquals} : the opposite check.
          * - {@link checkWrap.notLooseEquals} : the loose equality check.
          */
-        notStrictEquals: autoGuardSymbol,
+        notStrictEquals(actual, expected) {
+            if (actual === expected) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that two values are loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
@@ -470,7 +697,14 @@ export const simpleEqualityGuards = {
          * - {@link checkWrap.notLooseEquals} : the opposite check.
          * - {@link checkWrap.strictEquals} : the strict equality check.
          */
-        looseEquals: autoGuardSymbol,
+        looseEquals(actual, expected) {
+            if (actual == expected) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that two values are _not_ loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using)).
@@ -498,7 +732,14 @@ export const simpleEqualityGuards = {
          * - {@link checkWrap.looseEquals} : the opposite check.
          * - {@link checkWrap.strictEquals} : the strict equality check.
          */
-        notLooseEquals: autoGuardSymbol,
+        notLooseEquals(actual, expected) {
+            if (actual === expected) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
         /**
          * Checks that two values are deeply equal using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package. Returns the first value if
@@ -530,7 +771,14 @@ export const simpleEqualityGuards = {
          * - {@link checkWrap.entriesEqual} : a less expensive (but less thorough) deep equality check.
          * - {@link checkWrap.jsonEquals} : a less expensive (but less thorough) deep equality check.
          */
-        deepEquals: autoGuard(),
+        deepEquals(actual, expected) {
+            if (deepEqual(actual, expected)) {
+                return actual;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that two values are _not_ deeply equal using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package. Returns the first value if
@@ -562,7 +810,14 @@ export const simpleEqualityGuards = {
          * - {@link checkWrap.entriesEqual} : a less expensive (but less thorough) deep equality check.
          * - {@link checkWrap.jsonEquals} : a less expensive (but less thorough) deep equality check.
          */
-        notDeepEquals: autoGuardSymbol,
+        notDeepEquals(actual, expected) {
+            if (deepEqual(actual, expected)) {
+                return undefined;
+            }
+            else {
+                return actual;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -596,7 +851,7 @@ export const simpleEqualityGuards = {
          * - {@link waitUntil.notStrictEquals} : the opposite assertion.
          * - {@link waitUntil.looseEquals} : the loose equality assertion.
          */
-        strictEquals: autoGuard(),
+        strictEquals: createWaitUntil(assertions.strictEquals),
         /**
          * Repeatedly calls a callback until its output does _not_ strictly equal (using
          * [`===`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#strict_equality_using))
@@ -628,7 +883,7 @@ export const simpleEqualityGuards = {
          * - {@link waitUntil.strictEquals} : the opposite assertion.
          * - {@link waitUntil.notLooseEquals} : the loose equality assertion.
          */
-        notStrictEquals: autoGuardSymbol,
+        notStrictEquals: createWaitUntil(assertions.notStrictEquals),
         /**
          * Repeatedly calls a callback until its output loosely equals (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using))
@@ -660,7 +915,7 @@ export const simpleEqualityGuards = {
          * - {@link waitUntil.notLooseEquals} : the opposite assertion.
          * - {@link waitUntil.strictEquals} : the strict equality assertion.
          */
-        looseEquals: autoGuardSymbol,
+        looseEquals: createWaitUntil(assertions.looseEquals),
         /**
          * Repeatedly calls a callback until its output does _not_ loosely equal (using
          * [`==`](https://developer.mozilla.org/docs/Web/JavaScript/Equality_comparisons_and_sameness#loose_equality_using))
@@ -692,7 +947,7 @@ export const simpleEqualityGuards = {
          * - {@link waitUntil.looseEquals} : the opposite assertion.
          * - {@link waitUntil.notStrictEquals} : the strict equality assertion.
          */
-        notLooseEquals: autoGuardSymbol,
+        notLooseEquals: createWaitUntil(assertions.notLooseEquals),
         /**
          * Repeatedly calls a callback until its output deeply equals (using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package) the first input. Once the
@@ -727,7 +982,7 @@ export const simpleEqualityGuards = {
          * - {@link waitUntil.entriesEqual} : a less expensive (but less thorough) deep equality assertion.
          * - {@link waitUntil.jsonEquals} : a less expensive (but less thorough) deep equality assertion.
          */
-        deepEquals: autoGuard(),
+        deepEquals: createWaitUntil(assertions.deepEquals),
         /**
          * Repeatedly calls a callback until its output does _not_ deeply equal (using the
          * [deep-eql](https://www.npmjs.com/package/deep-eql) package) the first input. Once the
@@ -762,6 +1017,6 @@ export const simpleEqualityGuards = {
          * - {@link waitUntil.entriesEqual} : a less expensive (but less thorough) deep equality assertion.
          * - {@link waitUntil.jsonEquals} : a less expensive (but less thorough) deep equality assertion.
          */
-        notDeepEquals: autoGuardSymbol,
+        notDeepEquals: createWaitUntil(assertions.notDeepEquals),
     },
 };

package/dist/assertions/extendable-assertions.d.ts

@@ -1,5 +1,3 @@
-import type { ArrayElement } from '@augment-vir/core';
-import type { UnionToIntersection } from 'type-fest';
 import { booleanGuards } from './boolean.js';
 import { boundaryGuards } from './boundary.js';
 import { enumGuards } from './enum.js';
@@ -47,13 +45,3 @@ export declare const guardOverrides: [
     typeof httpGuards,
     typeof outputGuards
 ];
-export declare const checkOverrides: UnionToIntersection<ArrayElement<typeof guardOverrides>['check']>;
-export declare const assertWrapOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    assertWrap: any;
-}>['assertWrap']>;
-export declare const checkWrapOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    checkWrap: any;
-}>['checkWrap']>;
-export declare const waitUntilOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    waitUntil: any;
-}>['waitUntil']>;

package/dist/assertions/extendable-assertions.js

@@ -66,15 +66,3 @@ export const guardOverrides = [
     httpGuards,
     outputGuards,
 ];
-export const checkOverrides = Object.assign({}, ...guardOverrides.map((entry) => {
-    return entry.check;
-}));
-export const assertWrapOverrides = Object.assign({}, ...guardOverrides.map((entry) => {
-    return entry.assertWrap;
-}));
-export const checkWrapOverrides = Object.assign({}, ...guardOverrides.map((entry) => {
-    return entry.checkWrap;
-}));
-export const waitUntilOverrides = Object.assign({}, ...guardOverrides.map((entry) => {
-    return entry.waitUntil;
-}));

package/dist/assertions/http.d.ts

@@ -1,8 +1,5 @@
 import { HttpStatus, type HttpStatusByCategory, type HttpStatusCategory, type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
-import { autoGuardSymbol } from '../guard-types/guard-override.js';
 import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
-declare function isHttpStatus(actual: unknown, failureMessage?: string | undefined): asserts actual is HttpStatus;
-declare function isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined): asserts actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
 export declare const httpGuards: {
     assert: {
         /**
@@ -26,7 +23,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatus: typeof isHttpStatus;
+        isHttpStatus<Actual>(this: void, actual: unknown, failureMessage?: string | undefined): asserts actual is NarrowToExpected<Actual, HttpStatus>;
         /**
          * Asserts that a value is an {@link HttpStatus} within a specific {@link HttpStatusCategory}.
          *
@@ -49,7 +46,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatusCategory: typeof isHttpStatusCategory;
+        isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(this: void, actual: Actual, category: Category, failureMessage?: string | undefined): asserts actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
     };
     check: {
         /**
@@ -72,7 +69,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatus: typeof autoGuardSymbol;
+        isHttpStatus<Actual>(this: void, actual: Actual): actual is NarrowToExpected<Actual, HttpStatus>;
         /**
          * Checks that a value is an {@link HttpStatus} within a specific {@link HttpStatusCategory}.
          *
@@ -93,7 +90,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
+        isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(this: void, actual: Actual, category: Category): actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
     };
     assertWrap: {
         /**
@@ -117,7 +114,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatus: typeof autoGuardSymbol;
+        isHttpStatus<Actual>(this: void, actual: Actual, failureMessage?: string | undefined): NarrowToExpected<Actual, HttpStatus>;
         /**
          * Checks that a value is an {@link HttpStatus} within a specific {@link HttpStatusCategory}.
          * Returns the value if the assertion passes.
@@ -139,7 +136,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
+        isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(this: void, actual: Actual, category: Category, failureMessage?: string | undefined): NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
     };
     checkWrap: {
         /**
@@ -164,7 +161,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatus: typeof autoGuardSymbol;
+        isHttpStatus<Actual>(this: void, actual: Actual): NarrowToExpected<Actual, HttpStatus> | undefined;
         /**
          * Checks that a value is an {@link HttpStatus} within a specific {@link HttpStatusCategory}.
          * Returns the value if the check passes, otherwise `undefined`.
@@ -186,7 +183,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => NarrowToExpected<Actual, HttpStatusByCategory<Category>> | undefined;
+        isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(this: void, actual: Actual, category: Category): NarrowToExpected<Actual, HttpStatusByCategory<Category>> | undefined;
     };
     waitUntil: {
         /**
@@ -212,7 +209,7 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatus: typeof autoGuardSymbol;
+        isHttpStatus: <const Actual>(this: void, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, HttpStatus>>;
         /**
          * Repeatedly calls a callback until its output is an {@link HttpStatus} within a specific
          * {@link HttpStatusCategory}. Once the callback output passes, it is returned. If the
@@ -237,7 +234,6 @@ export declare const httpGuards: {
          * - {@link HttpStatus} : all included statuses.
          * - {@link HttpStatusCategory} : all status categories.
          */
-        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(category: Category, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, HttpStatusByCategory<Category>>>;
+        isHttpStatusCategory: <const Actual, const Category extends HttpStatusCategory>(this: void, category: Category, callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToExpected<Actual, HttpStatusByCategory<Category>>>;
     };
 };
-export {};