@augment-vir/assert 30.0.4 → 30.1.0

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

@@ -1,923 +1,52 @@
 import type { ArrayElement } from '@augment-vir/core';
 import type { UnionToIntersection } from 'type-fest';
-export declare const extendableAssertions: {
-    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;
-    };
-    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>>;
-    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;
-    lacksValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
-    isIn: typeof import("./values.js").isIn;
-    isNotIn: <const Parent extends object | string, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => asserts child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
-    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>;
-    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>;
-    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;
-    notLooseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
-    deepEquals: typeof import("./equality/simple-equality.js").deepEquals;
-    notDeepEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
-    isArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>;
-    isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
-    isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
-    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
-    isNull: (actual: unknown, failureMessage?: string | undefined) => asserts actual is null;
-    isNumber: (actual: unknown, failureMessage?: string | undefined) => asserts actual is number;
-    isObject: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").UnknownObject;
-    isString: (actual: unknown, failureMessage?: string | undefined) => asserts actual is string;
-    isSymbol: (actual: unknown, failureMessage?: string | undefined) => asserts actual is symbol;
-    isUndefined: (actual: unknown, failureMessage?: string | undefined) => asserts actual is undefined;
-    isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
-    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>;
-    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>;
-    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>>;
-    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>;
-    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;
-    isAtMost: (actual: number, expected: number, failureMessage?: string | undefined) => void;
-    isNaN: (actual: number, failureMessage?: string | undefined) => void;
-    isFinite: (actual: number, failureMessage?: string | undefined) => void;
-    isInfinite: (actual: number, failureMessage?: string | undefined) => void;
-    isApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
-    isNotApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
-    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;
-    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;
-    };
-    isLengthExactly: {
-        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").Tuple<Element, Length>;
-        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
-    };
-    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>;
-    lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Record<Key, any>>;
-    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>>>;
-    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;
-    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>;
-    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]}`>;
-    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;
-    endsWith: {
-        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-        (parent: string, child: string, failureMessage?: string | undefined): void;
-        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-    };
-    endsWithout: {
-        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-        (parent: string, child: string, failureMessage?: string | undefined): void;
-        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-    };
-    startsWith: {
-        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-        (parent: string, child: string, failureMessage?: string | undefined): void;
-        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-    };
-    startsWithout: {
-        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-        (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;
-    isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("./boolean.js").Truthy<Actual>;
-};
+import { booleanGuards } from './boolean.js';
+import { boundaryGuards } from './boundary.js';
+import { enumGuards } from './enum.js';
+import { entryEqualityGuards } from './equality/entry-equality.js';
+import { jsonEqualityGuards } from './equality/json-equality.js';
+import { simpleEqualityGuards } from './equality/simple-equality.js';
+import { httpGuards } from './http.js';
+import { instanceGuards } from './instance.js';
+import { keyGuards } from './keys.js';
+import { lengthGuards } from './length.js';
+import { nullishGuards } from './nullish.js';
+import { numericGuards } from './numeric.js';
+import { outputGuards } from './output.js';
+import { primitiveGuards } from './primitive.js';
+import { promiseGuards } from './promise.js';
+import { regexpGuards } from './regexp.js';
+import { runtimeTypeGuards } from './runtime-type.js';
+import { throwGuards } from './throws.js';
+import { uuidGuards } from './uuid.js';
+import { valueGuards } from './values.js';
+export declare const extendableAssertions: typeof booleanGuards.assert & typeof boundaryGuards.assert & typeof entryEqualityGuards.assert & typeof enumGuards.assert & typeof instanceGuards.assert & typeof jsonEqualityGuards.assert & typeof keyGuards.assert & typeof lengthGuards.assert & typeof nullishGuards.assert & typeof numericGuards.assert & typeof primitiveGuards.assert & typeof promiseGuards.assert & typeof regexpGuards.assert & typeof runtimeTypeGuards.assert & typeof simpleEqualityGuards.assert & typeof throwGuards.assert & typeof uuidGuards.assert & typeof valueGuards.assert & typeof httpGuards.assert & typeof outputGuards.assert;
 /**
  * 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: [{
-    assert: {
-        isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
-        isFalsy: (input: unknown, failureMessage?: string | undefined) => asserts input is import("./boolean.js").FalsyValue;
-        isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-        isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("./boolean.js").Truthy<Actual>;
-    };
-    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>;
-    };
-    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>;
-    };
-    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;
-    };
-    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>>;
-    };
-}, {
-    assert: {
-        endsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-            (parent: string, child: string, failureMessage?: string | undefined): void;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-        };
-        endsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-            (parent: string, child: string, failureMessage?: string | undefined): void;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-        };
-        startsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-            (parent: string, child: string, failureMessage?: string | undefined): void;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-        };
-        startsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
-            (parent: string, child: string, failureMessage?: string | undefined): void;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
-        };
-    };
-    check: {
-        endsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
-            (parent: string, child: string, failureMessage?: string | undefined): boolean;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
-        };
-        endsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
-            (parent: string, child: string, failureMessage?: string | undefined): boolean;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
-        };
-        startsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
-            (parent: string, child: string, failureMessage?: string | undefined): boolean;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
-        };
-        startsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
-            (parent: string, child: string, failureMessage?: string | undefined): boolean;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
-        };
-    };
-    assertWrap: {
-        endsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
-        };
-        endsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
-        };
-        startsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
-        };
-        startsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
-        };
-    };
-    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;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-        };
-        endsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-        };
-        startsWith: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-        };
-        startsWithout: {
-            <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
-            (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-            (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
-        };
-    };
-    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>;
-            (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-        };
-        endsWithout: {
-            <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>;
-            (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-        };
-        startsWith: {
-            <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>;
-            (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-        };
-        startsWithout: {
-            <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>;
-            (child: string, callback: () => import("@augment-vir/core").MaybePromise<string | ReadonlyArray<string>>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined): Promise<string | ReadonlyArray<string>>;
-        };
-    };
-}, {
-    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;
-    };
-    check: {
-        entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
-        notEntriesEqual: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-}, {
-    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]}`>;
-    };
-    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]}`>;
-    };
-    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]}`>;
-    };
-    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;
-    };
-    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]}`>>;
-    };
-}, {
-    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>;
-    };
-    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>;
-    };
-    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>;
-    };
-    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;
-    };
-    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>>;
-    };
-}, {
-    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;
-    };
-    check: {
-        jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
-        notJsonEquals: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-}, {
-    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>;
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Record<Key, any>>;
-        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>>>;
-    };
-    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>;
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => parent is Exclude<Parent, Record<Key, any>>;
-        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>>>;
-    };
-    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>;
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>>;
-        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>>>;
-    };
-    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;
-        lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>> | undefined;
-        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;
-    };
-    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>>;
-        lacksKey: <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<Exclude<Parent, Record<Key, any>>>;
-        hasKeys: <const Keys extends PropertyKey, const Parent>(keys: ReadonlyArray<Keys>, callback: () => import("@augment-vir/core").MaybePromise<Parent>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<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 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>>>>;
-    };
-}, {
-    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;
-        };
-        isLengthExactly: {
-            <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").Tuple<Element, Length>;
-            (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
-        };
-    };
-    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;
-        };
-        isLengthExactly: {
-            <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is import("@augment-vir/core").Tuple<Element, Length>;
-            (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
-        };
-    };
-    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;
-        };
-        isLengthExactly: {
-            <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").Tuple<Element, Length>;
-            <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual;
-        };
-    };
-    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;
-        };
-        isLengthExactly: {
-            <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").Tuple<Element, Length> | undefined;
-            <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual | undefined;
-        };
-    };
-    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>;
-        };
-        isLengthExactly: {
-            <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").Tuple<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>;
-        };
-    };
-}, {
-    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;
-    };
-    check: {
-        isDefined: <Actual>(input: Actual) => input is Exclude<Actual, undefined | null>;
-        isNullish: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
-    };
-    assertWrap: {
-        isDefined: <Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined | null>;
-        isNullish: typeof import("../guard-types/guard-override.js").autoGuardSymbol;
-    };
-    checkWrap: {
-        isDefined: undefined;
-        isNullish: undefined;
-    };
-    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;
-    };
-}, {
-    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;
-        isAtMost: (actual: number, expected: number, failureMessage?: string | undefined) => void;
-        isNaN: (actual: number, failureMessage?: string | undefined) => void;
-        isFinite: (actual: number, failureMessage?: string | undefined) => void;
-        isInfinite: (actual: number, failureMessage?: string | undefined) => void;
-        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;
-    };
-}, {
-    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>;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-}, {
-    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>>;
-    };
-    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>>;
-    };
-    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>>;
-    };
-    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;
-    };
-    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>>>;
-    };
-}, {
-    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;
-    };
-}, {
-    assert: {
-        isArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>;
-        isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
-        isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
-        isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
-        isNull: (actual: unknown, failureMessage?: string | undefined) => asserts actual is null;
-        isNumber: (actual: unknown, failureMessage?: string | undefined) => asserts actual is number;
-        isObject: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").UnknownObject;
-        isString: (actual: unknown, failureMessage?: string | undefined) => asserts actual is string;
-        isSymbol: (actual: unknown, failureMessage?: string | undefined) => asserts actual is symbol;
-        isUndefined: (actual: unknown, failureMessage?: string | undefined) => asserts actual is undefined;
-        isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
-        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>;
-    };
-    check: {
-        isArray: <Actual>(actual: Actual) => actual is Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>;
-        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>;
-        isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
-        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, null>;
-        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>;
-        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>;
-    };
-    assertWrap: {
-        isArray: <Actual>(actual: Actual) => Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>;
-        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>;
-        isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").AnyFunction>;
-        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, null>;
-        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>;
-        isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol>;
-        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
-    };
-    checkWrap: {
-        isArray: <Actual>(actual: Actual) => (Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>) | undefined;
-        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;
-        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;
-        isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").AnyFunction> | undefined;
-        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, null> | undefined;
-        isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, number> | undefined;
-        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;
-    };
-    waitUntil: {
-        isArray: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Extract<Actual, unknown[]> extends never ? Extract<Actual, readonly unknown[]> extends never ? unknown[] extends Actual ? Actual & unknown[] : never : Extract<Actual, readonly unknown[]> : Extract<Actual, unknown[]>>;
-        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>>;
-        isNotFunction: <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").AnyFunction>>;
-        isNotNull: <const Actual>(callback: () => import("@augment-vir/core").MaybePromise<Actual>, options?: import("../index.js").WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, null>>;
-        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>>;
-        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>>;
-    };
-}, {
-    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;
-        notLooseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
-        deepEquals: typeof import("./equality/simple-equality.js").deepEquals;
-        notDeepEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-}, {
-    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;
-    };
-    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;
-    };
-    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;
-    };
-    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;
-    };
-    waitUntil: {
-        throws: {
-            (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;
-    };
-}, {
-    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>;
-    };
-    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>;
-    };
-    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>;
-    };
-    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;
-    };
-    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>>;
-    };
-}, {
-    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;
-        lacksValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
-        isIn: typeof import("./values.js").isIn;
-        isNotIn: <const Parent extends object | string, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => asserts child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
-        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>;
-    };
-    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>;
-    };
-    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>;
-    };
-    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;
-    };
-    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>>;
-    };
-}, {
-    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>>;
-    };
-    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>>;
-    };
-    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>>;
-    };
-    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;
-    };
-    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>>>;
-    };
-}, {
-    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;
-        };
-    };
-    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;
-        };
-    };
-    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>>>;
-        };
-    };
-    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;
-        };
-    };
-    waitUntil: {
-        output: typeof import("./output.js").waitUntilOutput;
-    };
-}];
+export declare const guardOverrides: [
+    typeof booleanGuards,
+    typeof boundaryGuards,
+    typeof entryEqualityGuards,
+    typeof enumGuards,
+    typeof instanceGuards,
+    typeof jsonEqualityGuards,
+    typeof keyGuards,
+    typeof lengthGuards,
+    typeof nullishGuards,
+    typeof numericGuards,
+    typeof primitiveGuards,
+    typeof promiseGuards,
+    typeof regexpGuards,
+    typeof runtimeTypeGuards,
+    typeof simpleEqualityGuards,
+    typeof throwGuards,
+    typeof uuidGuards,
+    typeof valueGuards,
+    typeof httpGuards,
+    typeof outputGuards
+];
 export declare const checkOverrides: UnionToIntersection<ArrayElement<typeof guardOverrides>['check']>;
 export declare const assertWrapOverrides: UnionToIntersection<Extract<ArrayElement<typeof guardOverrides>, {
     assertWrap: any;