@augment-vir/assert 30.0.4 → 30.0.5

package/dist/assertions/http.d.ts

@@ -1,6 +1,6 @@
 import { HttpStatus, type HttpStatusByCategory, type HttpStatusCategory, type MaybePromise, type NarrowToExpected } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import type { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function isHttpStatus(actual: unknown, failureMessage?: string | undefined): asserts actual is HttpStatus;
 declare function isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined): asserts actual is NarrowToExpected<Actual, HttpStatusByCategory<Category>>;
 export declare const httpGuards: {

package/dist/assertions/instance.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise } from '@augment-vir/core';
-import { Constructor } from 'type-fest';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type MaybePromise } from '@augment-vir/core';
+import { type Constructor } from 'type-fest';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 /** Wraps the JavaScript built-in "instanceof" in a type guard assertion. */
 declare function instanceOf<const Instance>(instance: unknown, 
 /** The constructor that the "instance" input will be checked against. */

package/dist/assertions/keys.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise, NarrowToExpected, type RequiredKeysOf } from '@augment-vir/core';
-import { SetRequired } from 'type-fest';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type MaybePromise, type NarrowToExpected, type RequiredKeysOf } from '@augment-vir/core';
+import { type SetRequired } from 'type-fest';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function isKeyOf<const Parent>(key: PropertyKey, parent: Parent, failureMessage?: string | undefined): asserts key is keyof Parent;
 declare function isNotKeyOf<const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined): asserts key is Exclude<Key, RequiredKeysOf<Parent>>;
 /** Helper type for `hasKey`. */

package/dist/assertions/keys.js

@@ -1,4 +1,4 @@
-import { stringify } from '@augment-vir/core';
+import { stringify, } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
 import { createCheck } from '../guard-types/check-function.js';
 import { autoGuard } from '../guard-types/guard-override.js';

package/dist/assertions/length.d.ts

@@ -1,5 +1,5 @@
-import { MaybePromise, Tuple, type AnyObject, type AtLeastTuple } from '@augment-vir/core';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type AnyObject, type AtLeastTuple, type MaybePromise, type Tuple } from '@augment-vir/core';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function isLengthAtLeast<const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is AtLeastTuple<Element, Length>;
 declare function isLengthAtLeast(actual: string | AnyObject, length: number, failureMessage?: string | undefined): void;
 declare function isLengthExactly<const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is Tuple<Element, Length>;

package/dist/assertions/nullish.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise } from '@augment-vir/core';
+import { type MaybePromise } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function isDefined<const Actual>(
 /** The value to check. */
 input: Actual, 

package/dist/assertions/output.d.ts

@@ -1,6 +1,6 @@
-import { AnyFunction } from '@augment-vir/core';
+import { type AnyFunction } from '@augment-vir/core';
 import type { IsAny } from 'type-fest';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 /**
  * A customer asserter for `.output` guards (`assert.output`, `check.output`, etc.). This is
  * typically not necessary, as the `.output` guards already perform deep equality checks by

package/dist/assertions/primitive.d.ts

@@ -1,7 +1,7 @@
-import type { MaybePromise } from '@augment-vir/core';
-import { Primitive } from 'type-fest';
+import { type MaybePromise } from '@augment-vir/core';
+import { type Primitive } from 'type-fest';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 export type { Primitive } from 'type-fest';
 /** Asserts that the given value is a primitive. */
 declare function isPrimitive(input: unknown, failureMessage?: string | undefined): asserts input is Primitive;

package/dist/assertions/promise.d.ts

@@ -1,5 +1,5 @@
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function isPromiseLike(actual: unknown, failureMessage?: string | undefined): asserts actual is PromiseLike<any>;
 declare function isNotPromiseLike<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, PromiseLike<any>>;
 /**

package/dist/assertions/runtime-type.d.ts

@@ -1,6 +1,6 @@
-import { AnyFunction, MaybePromise, NarrowToActual, NarrowToExpected, UnknownObject } from '@augment-vir/core';
+import { type AnyFunction, type MaybePromise, type NarrowToActual, type NarrowToExpected, type UnknownObject } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 type ArrayNarrow<Actual> = Extract<Actual, unknown[]> extends never ? Extract<Actual, ReadonlyArray<unknown>> extends never ? unknown[] extends Actual ? unknown[] : never : Extract<Actual, ReadonlyArray<unknown>> : Extract<Actual, unknown[]>;
 declare function isNotArray<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
 declare function isNotBigInt<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, bigint>;
@@ -477,7 +477,7 @@ export declare const runtimeTypeGuards: {
          * @see
          * - {@link check.isNotFunction} : the opposite check.
          */
-        isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is NarrowToActual<Actual, AnyFunction>;
+        isFunction: <const Actual>(actual: Actual) => actual is NarrowToActual<Actual, AnyFunction>;
         /**
          * Checks that a value is exactly `null`.
          *

package/dist/assertions/throws.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise, PartialWithNullable, TypedFunction } from '@augment-vir/core';
+import { type MaybePromise, type PartialWithNullable, type TypedFunction } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function isError(actual: unknown, matchOptions?: ErrorMatchOptions | undefined, failureMessage?: string | undefined): asserts actual is Error;
 /**
  * A type that represents possible error matching patterns. This is used by the `.throws` and

package/dist/assertions/uuid.d.ts

@@ -1,6 +1,6 @@
-import { MaybePromise, Uuid } from '@augment-vir/core';
+import { type MaybePromise, type Uuid } from '@augment-vir/core';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 /** Checks if the input string is a valid v4 UUID. */
 declare function isUuid(actual: unknown, failureMessage?: string | undefined): asserts actual is Uuid;
 declare function isNotUuid<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, Uuid>;

package/dist/assertions/values.d.ts

@@ -1,8 +1,8 @@
 import type { NarrowToActual, NarrowToExpected } from '@augment-vir/core';
-import { AnyObject, MaybePromise, Values } from '@augment-vir/core';
+import { type AnyObject, type MaybePromise, type Values } from '@augment-vir/core';
 import type { EmptyObject } from 'type-fest';
 import { autoGuardSymbol } from '../guard-types/guard-override.js';
-import type { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
 declare function hasValue(parent: object, value: unknown, failureMessage?: string | undefined): void;
 declare function lacksValue(parent: object, value: unknown, failureMessage?: string | undefined): void;
 declare function hasValues(parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined): void;

package/dist/augments/guards/assert-wrap.d.ts

@@ -1,257 +1,6 @@
-declare const assertWrapGroup: import("../../guard-types/assert-wrap-function.js").AssertWrapGroup<{
-    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("../assertion-exports.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("../../assertions/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("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
-    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("../assertion-exports.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("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
-        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<void>;
-        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): void;
-        (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<void>;
-    };
-    isError: (actual: unknown, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
-    strictEquals: typeof import("../../assertions/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("../../assertions/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("../../assertions/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("../assertion-exports.js").FalsyValue;
-    isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("../assertion-exports.js").Truthy<Actual>;
-}, {
-    isFalse: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isFalsy: <T>(input: T, failureMessage?: string | undefined) => import("../assertion-exports.js").Falsy<T>;
-    isTrue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isTruthy: <T>(input: T, failureMessage?: string | undefined) => import("../assertion-exports.js").Truthy<T>;
-} & {
-    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;
-} & {
-    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("../assertion-exports.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>>>;
-    };
-} & {
-    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>;
-} & {
-    throws: {
-        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
-        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
-        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
-        (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error>;
-    };
-    isError: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-} & {
-    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("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
-    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => Exclude<Actual, import("../assertion-exports.js").Empty>;
-} & {
-    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;
-    };
-} & {
-    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]}`>;
-} & {
-    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;
-} & {
-    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;
-} & {
-    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>>;
-} & {
-    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>;
-} & {
-    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>>>;
-} & {
-    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;
-    };
-} & {
-    isDefined: <Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined | null>;
-    isNullish: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-} & {
-    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;
-} & {
-    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;
-} & {
-    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>>;
-} & {
-    matches: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    mismatches: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-} & {
-    isUuid: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").Uuid>;
-}>;
+import { assertWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
+import { AssertWrapGroup } from '../../guard-types/assert-wrap-function.js';
+declare const assertWrapGroup: AssertWrapGroup<typeof extendableAssertions, typeof assertWrapOverrides>;
 /**
  * A group of guard methods that do the following:
  *