@augment-vir/assert 30.0.0 → 30.0.1

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

@@ -17,13 +17,13 @@ export declare const extendableAssertions: {
     isNotEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("./values.js").Empty>;
     isUuid: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").Uuid;
     isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
-    isError: (actual: unknown, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
     throws: {
         (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
         (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<void>;
         (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
         (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<void>;
     };
+    isError: (actual: unknown, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
     strictEquals: typeof import("./equality/simple-equality.js").strictEquals;
     notStrictEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
     looseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
@@ -44,12 +44,12 @@ export declare const extendableAssertions: {
     isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, bigint>;
     isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, boolean>;
     isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, number>;
     isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
     isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, string>;
     isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, symbol>;
     isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, undefined>;
-    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
@@ -113,39 +113,48 @@ export declare const extendableAssertions: {
         (parent: string, child: string, failureMessage?: string | undefined): void;
         (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
     };
+    isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
     isFalsy: (input: unknown, failureMessage?: string | undefined) => asserts input is import("./boolean.js").FalsyValue;
-    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("./boolean.js").Truthy<Actual>;
     isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-    isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
+    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("./boolean.js").Truthy<Actual>;
 };
 /**
  * These overrides are required for more complex guards because TypeScript won't allow us to
  * maintain function type parameters when mapping such functions.
  */
 export declare const guardOverrides: [{
-    assertions: {
+    assert: {
+        isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
         isFalsy: (input: unknown, failureMessage?: string | undefined) => asserts input is import("./boolean.js").FalsyValue;
-        isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("./boolean.js").Truthy<Actual>;
         isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-        isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
+        isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("./boolean.js").Truthy<Actual>;
     };
-    checkOverrides: {
+    check: {
+        isFalse: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isFalsy: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isTrue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isTruthy: <T>(input: T) => input is import("./boolean.js").Truthy<T>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
+        isFalse: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFalsy: <T>(input: T, failureMessage?: string | undefined) => import("./boolean.js").Falsy<T>;
+        isTrue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isTruthy: <T>(input: T, failureMessage?: string | undefined) => import("./boolean.js").Truthy<T>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
+        isFalse: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFalsy: <T>(input: T) => import("./boolean.js").Falsy<T> | undefined;
+        isTrue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isTruthy: <T>(input: T) => import("./boolean.js").Truthy<T> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
+        isFalse: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFalsy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("./boolean.js").Falsy<Actual>>;
+        isTrue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isTruthy: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("./boolean.js").Truthy<Actual>>;
     };
 }, {
-    assertions: {
+    assert: {
         endsWith: {
             <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
             (parent: string, child: string, failureMessage?: string | undefined): void;
@@ -167,7 +176,7 @@ export declare const guardOverrides: [{
             (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
         };
     };
-    checkOverrides: {
+    check: {
         endsWith: {
             <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
             (parent: string, child: string, failureMessage?: string | undefined): boolean;
@@ -189,7 +198,7 @@ export declare const guardOverrides: [{
             (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
         };
     };
-    assertWrapOverrides: {
+    assertWrap: {
         endsWith: {
             <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
             (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
@@ -211,7 +220,7 @@ export declare const guardOverrides: [{
             (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
         };
     };
-    checkWrapOverrides: {
+    checkWrap: {
         endsWith: {
             <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
             (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
@@ -233,7 +242,7 @@ export declare const guardOverrides: [{
             (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
         };
     };
-    waitUntilOverrides: {
+    waitUntil: {
         endsWith: {
             <const ArrayElement>(child: ArrayElement, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<ArrayElement>>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<ReadonlyArray<ArrayElement>>;
             (child: string, callback: () => import("@augment-vir/core").MaybePromise<string>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string>;
@@ -256,83 +265,91 @@ export declare const guardOverrides: [{
         };
     };
 }, {
-    assertions: {
+    assert: {
         entriesEqual: <const Actual extends object, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
         notEntriesEqual: (actual: object, expected: object, failureMessage?: string | undefined) => void;
     };
-    checkOverrides: {
+    check: {
         entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+        notEntriesEqual: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+        notEntriesEqual: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected> | undefined;
+        notEntriesEqual: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         entriesEqual: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+        notEntriesEqual: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
 }, {
-    assertions: {
+    assert: {
         isEnumValue: typeof import("./enum.js").isEnumValue;
         isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => asserts child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
     };
-    checkOverrides: {
+    check: {
         isEnumValue: <const Expected extends import("@augment-vir/core").EnumBaseType>(child: unknown, checkEnum: Expected) => child is Expected[keyof Expected];
         isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]>;
         isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]> | undefined;
         isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(checkEnum: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]>>;
         isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(checkEnum: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>>;
     };
 }, {
-    assertions: {
+    assert: {
         instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Instance;
         notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Exclude<Actual, Instance>;
     };
-    checkOverrides: {
+    check: {
         instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>) => instance is Instance;
         notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>) => instance is Exclude<Actual, Instance>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => Instance;
         notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => Exclude<Actual, Instance>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>) => Instance | undefined;
         notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>) => Exclude<Actual, Instance> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         instanceOf: <const Instance>(constructor: import("type-fest").Constructor<Instance>, callback: () => import("@augment-vir/core").MaybePromise<unknown>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Instance>;
         notInstanceOf: <const Actual, const Instance>(constructor: import("type-fest").Constructor<Instance>, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Instance>>;
     };
 }, {
-    assertions: {
+    assert: {
         jsonEquals: <const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
         notJsonEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
     };
-    checkOverrides: {
+    check: {
         jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+        notJsonEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+        notJsonEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected> | undefined;
+        notJsonEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         jsonEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+        notJsonEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
 }, {
-    assertions: {
+    assert: {
         isKeyOf: <const Parent>(key: PropertyKey, parent: Parent, failureMessage?: string | undefined) => asserts key is keyof Parent;
         isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => asserts key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
         hasKey: <const Key extends PropertyKey, const Parent>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
@@ -340,7 +357,7 @@ export declare const guardOverrides: [{
         hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => asserts parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
         lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
     };
-    checkOverrides: {
+    check: {
         isKeyOf: <const Parent>(key: PropertyKey, parent: Parent) => key is keyof Parent;
         isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
         hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => parent is Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
@@ -348,7 +365,7 @@ export declare const guardOverrides: [{
         hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
         lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => parent is Exclude<Parent, Partial<Record<Key, any>>>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Key, keyof Parent>;
         isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
         hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
@@ -356,7 +373,7 @@ export declare const guardOverrides: [{
         hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
         lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>, failureMessage?: string | undefined) => Exclude<Parent, Partial<Record<Key, any>>>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent) => import("@augment-vir/core").NarrowToExpected<Key, keyof Parent> | undefined;
         isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>> | undefined;
         hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => (Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>) | undefined;
@@ -364,7 +381,7 @@ export declare const guardOverrides: [{
         hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => (Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>) | undefined;
         lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => Exclude<Parent, Partial<Record<Key, any>>> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         isKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Key>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Key, keyof Parent>>;
         isNotKeyOf: <const Key extends PropertyKey, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Key>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>>;
         hasKey: <const Parent, const Key extends PropertyKey>(key: Key, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>>;
@@ -373,7 +390,7 @@ export declare const guardOverrides: [{
         lacksKeys: <const Parent, const Keys extends PropertyKey>(keys: ReadonlyArray<Keys>, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Partial<Record<Keys, any>>>>;
     };
 }, {
-    assertions: {
+    assert: {
         isLengthAtLeast: {
             <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
             (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
@@ -383,7 +400,7 @@ export declare const guardOverrides: [{
             (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
         };
     };
-    checkOverrides: {
+    check: {
         isLengthAtLeast: {
             <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
             (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
@@ -393,7 +410,7 @@ export declare const guardOverrides: [{
             (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
         };
     };
-    assertWrapOverrides: {
+    assertWrap: {
         isLengthAtLeast: {
             <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").AtLeastTuple<Element, Length>;
             <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual;
@@ -403,7 +420,7 @@ export declare const guardOverrides: [{
             <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual;
         };
     };
-    checkWrapOverrides: {
+    checkWrap: {
         isLengthAtLeast: {
             <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").AtLeastTuple<Element, Length> | undefined;
             <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual | undefined;
@@ -413,7 +430,7 @@ export declare const guardOverrides: [{
             <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual | undefined;
         };
     };
-    waitUntilOverrides: {
+    waitUntil: {
         isLengthAtLeast: {
             <Element, Length extends number>(length: Length, callback: () => import("@augment-vir/core").MaybePromise<ReadonlyArray<Element | undefined>>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<import("@augment-vir/core").AtLeastTuple<Element, Length>>;
             <Actual extends string | import("@augment-vir/core").AnyObject>(length: number, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Actual>;
@@ -424,25 +441,28 @@ export declare const guardOverrides: [{
         };
     };
 }, {
-    assertions: {
+    assert: {
         isDefined: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, undefined | null>;
         isNullish: (input: unknown, failureMessage?: string | undefined) => asserts input is null | undefined;
     };
-    checkOverrides: {
+    check: {
         isDefined: <Actual>(input: Actual) => input is Exclude<Actual, undefined | null>;
+        isNullish: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         isDefined: <Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined | null>;
+        isNullish: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         isDefined: undefined;
         isNullish: undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         isDefined: <Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined | null>>;
+        isNullish: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
 }, {
-    assertions: {
+    assert: {
         isAbove: (actual: number, expected: number, failureMessage?: string | undefined) => void;
         isAtLeast: (actual: number, expected: number, failureMessage?: string | undefined) => void;
         isBelow: (actual: number, expected: number, failureMessage?: string | undefined) => void;
@@ -453,63 +473,135 @@ export declare const guardOverrides: [{
         isApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
         isNotApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
     };
+    check: {
+        isAbove: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtLeast: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBelow: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtMost: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNaN: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isFinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isInfinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNotApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
+    assertWrap: {
+        isAbove: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtLeast: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBelow: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtMost: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNaN: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isFinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isInfinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNotApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
+    checkWrap: {
+        isAbove: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtLeast: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBelow: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtMost: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNaN: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isFinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isInfinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNotApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
+    waitUntil: {
+        isAbove: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtLeast: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBelow: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isAtMost: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNaN: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isFinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isInfinite: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNotApproximately: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
 }, {
-    assertions: {
+    assert: {
         isPropertyKey: (input: unknown, failureMessage?: string | undefined) => asserts input is PropertyKey;
         isNotPropertyKey: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, PropertyKey>;
         isPrimitive: (input: unknown, failureMessage?: string | undefined) => asserts input is import("type-fest").Primitive;
         isNotPrimitive: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, import("type-fest").Primitive>;
     };
-    checkOverrides: {
+    check: {
         isNotPrimitive: <const Actual>(input: Actual) => input is Exclude<Actual, import("type-fest").Primitive>;
         isNotPropertyKey: <const Actual>(input: Actual) => input is Exclude<Actual, PropertyKey>;
+        isPrimitive: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isPropertyKey: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         isNotPrimitive: <const Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("type-fest").Primitive>;
         isNotPropertyKey: <const Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, PropertyKey>;
+        isPrimitive: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isPropertyKey: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         isNotPrimitive: <const Actual>(input: Actual) => Exclude<Actual, import("type-fest").Primitive> | undefined;
         isNotPropertyKey: <const Actual>(input: Actual) => Exclude<Actual, PropertyKey> | undefined;
+        isPrimitive: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isPropertyKey: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         isNotPrimitive: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("type-fest").Primitive>>;
         isNotPropertyKey: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PropertyKey>>;
+        isPrimitive: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isPropertyKey: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
 }, {
-    assertions: {
+    assert: {
         isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
         isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, PromiseLike<any>>;
         isPromise: (actual: unknown, failureMessage?: string | undefined) => asserts actual is Promise<any>;
         isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, Promise<any>>;
     };
-    checkOverrides: {
-        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
+    check: {
+        isPromiseLike: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, PromiseLike<any>>;
+        isPromise: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
     };
-    assertWrapOverrides: {
-        isPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, Promise<any>>;
-        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>>;
+    assertWrap: {
         isPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, PromiseLike<any>>;
         isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, PromiseLike<any>>;
+        isPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, Promise<any>>;
+        isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>> | undefined;
         isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, PromiseLike<any>> | undefined;
+        isPromise: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isPromiseLike: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    waitUntilOverrides: {
-        isPromise: <const Actual>(callback: () => Actual, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, Promise<any>>>;
-        isNotPromise: <const Actual>(callback: () => Actual, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
+    waitUntil: {
         isPromiseLike: <const Actual>(callback: () => Actual, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, PromiseLike<any>>>;
         isNotPromiseLike: <const Actual>(callback: () => Actual, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, PromiseLike<any>>>;
+        isPromise: <const Actual>(callback: () => Actual, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, Promise<any>>>;
+        isNotPromise: <const Actual>(callback: () => Actual, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, Promise<any>>>;
     };
 }, {
-    assertions: {
+    assert: {
         matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
         mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     };
+    check: {
+        matches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        mismatches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
+    assertWrap: {
+        matches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        mismatches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
+    checkWrap: {
+        matches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        mismatches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
+    waitUntil: {
+        matches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        mismatches: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+    };
 }, {
-    assertions: {
+    assert: {
         isArray: (actual: unknown, failureMessage?: string | undefined) => asserts actual is unknown[];
         isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
         isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
@@ -524,15 +616,24 @@ export declare const guardOverrides: [{
         isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, bigint>;
         isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, boolean>;
         isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
         isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, number>;
         isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
         isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, string>;
         isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, symbol>;
         isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, undefined>;
-        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     };
-    checkOverrides: {
+    check: {
+        isArray: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBigInt: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBoolean: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+        isNull: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNumber: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isObject: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isString: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isSymbol: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isUndefined: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, ReadonlyArray<unknown>>;
         isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, bigint>;
         isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, boolean>;
@@ -541,12 +642,20 @@ export declare const guardOverrides: [{
         isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, number>;
         isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
         isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, string>;
-        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, undefined>;
         isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, symbol>;
+        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, undefined>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
+        isArray: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBigInt: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBoolean: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+        isNull: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNumber: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isObject: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isString: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, symbol>;
+        isUndefined: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>>;
         isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint>;
         isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean>;
@@ -555,13 +664,20 @@ export declare const guardOverrides: [{
         isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, number>;
         isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").UnknownObject>;
         isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, string>;
-        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
         isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol>;
+        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
+        isArray: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBigInt: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBoolean: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFunction: <const Actual>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction> | undefined;
+        isNull: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNumber: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isObject: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isString: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isSymbol: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isUndefined: undefined;
-        isNotUndefined: undefined;
         isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>> | undefined;
         isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint> | undefined;
         isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean> | undefined;
@@ -571,9 +687,19 @@ export declare const guardOverrides: [{
         isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").UnknownObject> | undefined;
         isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, string> | undefined;
         isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol> | undefined;
+        isNotUndefined: undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
+        isArray: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBigInt: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isBoolean: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isFunction: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>>;
+        isNull: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isNumber: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isObject: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isString: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isSymbol: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        isUndefined: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotArray: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, ReadonlyArray<unknown>>>;
         isNotBigInt: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, bigint>>;
         isNotBoolean: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, boolean>>;
@@ -582,11 +708,11 @@ export declare const guardOverrides: [{
         isNotNumber: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, number>>;
         isNotObject: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").UnknownObject>>;
         isNotString: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, string>>;
-        isNotUndefined: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
         isNotSymbol: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, symbol>>;
+        isNotUndefined: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
     };
 }, {
-    assertions: {
+    assert: {
         strictEquals: typeof import("./equality/simple-equality.js").strictEquals;
         notStrictEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
         looseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
@@ -594,81 +720,105 @@ export declare const guardOverrides: [{
         deepEquals: typeof import("./equality/simple-equality.js").deepEquals;
         notDeepEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
     };
-    checkOverrides: {
+    check: {
         strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+        notStrictEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        looseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        notLooseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+        notDeepEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+        notStrictEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        looseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        notLooseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+        notDeepEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => Expected | undefined;
+        notStrictEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        looseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        notLooseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected> | undefined;
+        notDeepEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         strictEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+        notStrictEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        looseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        notLooseEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         deepEquals: <Actual, Expected extends Actual>(expected: Expected, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, Expected>>;
+        notDeepEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
 }, {
-    assertions: {
-        isError: (actual: unknown, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
+    assert: {
         throws: {
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<void>;
             (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
             (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<void>;
         };
+        isError: (actual: unknown, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
     };
-    checkOverrides: {
+    check: {
         throws: {
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined): boolean;
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined): Promise<boolean>;
             (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined): boolean;
             (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined): import("@augment-vir/core").MaybePromise<boolean>;
         };
+        isError: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    assertWrapOverrides: {
+    assertWrap: {
         throws: {
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
             (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
             (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error>;
         };
+        isError: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    checkWrapOverrides: {
+    checkWrap: {
         throws: {
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error | undefined;
             (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<Error | undefined>;
             (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error | undefined;
             (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("./throws.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error | undefined>;
         };
+        isError: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
-    waitUntilOverrides: {
+    waitUntil: {
         throws: {
-            (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, any> | Promise<any>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
-            (matchOptions: import("./throws.js").ErrorMatchOptions, callbackOrPromise: import("@augment-vir/core").TypedFunction<void, any> | Promise<any>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
+            (callback: import("@augment-vir/core").TypedFunction<void, any>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
+            (matchOptions: import("./throws.js").ErrorMatchOptions, callback: import("@augment-vir/core").TypedFunction<void, any>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
         };
+        isError: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
     };
 }, {
-    assertions: {
+    assert: {
         isUuid: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").Uuid;
         isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
     };
-    checkOverrides: {
+    check: {
+        isUuid: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
+        isUuid: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").Uuid>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
+        isUuid: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").Uuid> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
+        isUuid: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isNotUuid: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("@augment-vir/core").Uuid>>;
     };
 }, {
-    assertions: {
+    assert: {
         hasValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
         lacksValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
         hasValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
@@ -678,85 +828,103 @@ export declare const guardOverrides: [{
         isEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("./values.js").Empty>;
         isNotEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("./values.js").Empty>;
     };
-    checkOverrides: {
+    check: {
+        hasValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        hasValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isIn: <const Parent>(child: unknown, parent: Parent) => child is import("@augment-vir/core").Values<Parent>;
         isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
         isEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual) => actual is import("@augment-vir/core").NarrowToActual<Actual, import("./values.js").Empty>;
         isNotEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual) => actual is Exclude<Actual, import("./values.js").Empty>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
+        hasValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        hasValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isIn: <const Child, const Parent>(child: Child, parent: Parent, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>>;
         isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, import("@augment-vir/core").Values<Parent>>;
         isEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("./values.js").Empty>;
         isNotEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual) => Exclude<Actual, import("./values.js").Empty>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
+        hasValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        hasValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isIn: <const Child, const Parent>(child: Child, parent: Parent) => import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>> | undefined;
         isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, import("@augment-vir/core").Values<Parent>> | undefined;
         isEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, import("./values.js").Empty> | undefined;
         isNotEmpty: <const Actual extends import("./values.js").CanBeEmpty>(actual: Actual) => Exclude<Actual, import("./values.js").Empty> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
+        hasValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValue: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        hasValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
+        lacksValues: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isIn: <const Child, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Child>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>>>;
         isNotIn: <const Child, const Parent>(parent: Parent, callback: () => import("@augment-vir/core").MaybePromise<Child>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Child, import("@augment-vir/core").Values<Parent>>>;
         isEmpty: <const Actual extends import("./values.js").CanBeEmpty>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToActual<Actual, import("./values.js").Empty>>;
         isNotEmpty: <const Actual extends import("./values.js").CanBeEmpty>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, import("./values.js").Empty>>;
     };
 }, {
-    assertions: {
+    assert: {
         isHttpStatus: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").HttpStatus;
         isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
     };
-    checkOverrides: {
+    check: {
+        isHttpStatus: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
     };
-    assertWrapOverrides: {
+    assertWrap: {
+        isHttpStatus: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
     };
-    checkWrapOverrides: {
+    checkWrap: {
+        isHttpStatus: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>> | undefined;
     };
-    waitUntilOverrides: {
+    waitUntil: {
+        isHttpStatus: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
         isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(category: Category, callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>>;
     };
 }, {
-    assertions: {
+    assert: {
         output: {
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("./output.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
         };
     };
-    checkOverrides: {
+    check: {
         output: {
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? boolean : Promise<boolean> : boolean;
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("./output.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? boolean : Promise<boolean> : boolean;
         };
     };
-    assertWrapOverrides: {
+    assertWrap: {
         output: {
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>>> : Awaited<ReturnType<NoInfer<FunctionToCall>>>;
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("./output.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>>> : Awaited<ReturnType<NoInfer<FunctionToCall>>>;
         };
     };
-    checkWrapOverrides: {
+    checkWrap: {
         output: {
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined> : Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined;
             <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("./output.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined> : Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined;
         };
     };
-    waitUntilOverrides: {
+    waitUntil: {
         output: typeof import("./output.js").waitUntilOutput;
     };
 }];
-export declare const checkOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    checkOverrides: any;
-}>['checkOverrides']>;
+export declare const checkOverrides: UnionToIntersection<ArrayElement<typeof guardOverrides>['check']>;
 export declare const assertWrapOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    assertWrapOverrides: any;
-}>['assertWrapOverrides']>;
+    assertWrap: any;
+}>['assertWrap']>;
 export declare const checkWrapOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    checkWrapOverrides: any;
-}>['checkWrapOverrides']>;
+    checkWrap: any;
+}>['checkWrap']>;
 export declare const waitUntilOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
-    waitUntilOverrides: any;
-}>['waitUntilOverrides']>;
+    waitUntil: any;
+}>['waitUntil']>;