@augment-vir/assert 30.0.3 → 30.0.5

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

@@ -1,4 +1,6 @@
-declare const allAssertions: {
+import { tsTypeGuards } from '../../assertions/equality/ts-type-equality.js';
+import { extendableAssertions } from '../../assertions/extendable-assertions.js';
+declare const extraAssertions: {
     /**
      * Immediately throw an assertion error.
      *
@@ -13,161 +15,8 @@ declare const allAssertions: {
      * @throws {@link AssertionError}
      */
     fail: (failureMessage?: string | undefined) => never;
-    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: (actual: unknown, failureMessage?: string | undefined) => asserts actual is unknown[];
-    isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
-    isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
-    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>;
-    tsType: {
-        <Actual>(input: Actual): {
-            equals: {
-                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
-                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
-            };
-            notEquals: {
-                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
-                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
-            };
-            matches: {
-                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
-                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
-            };
-            notMatches: {
-                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
-                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
-            };
-        };
-        <Actual>(): {
-            equals: {
-                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
-                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
-            };
-            notEquals: {
-                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
-                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
-            };
-            matches: {
-                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
-                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
-            };
-            notMatches: {
-                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
-                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
-            };
-        };
-    };
 };
+declare const allAssertions: typeof tsTypeGuards.assert & typeof extendableAssertions & typeof extraAssertions;
 /**
  * A group of guard methods that assert their conditions and do nothing else.
  *

package/dist/augments/guards/assert.js

@@ -1,9 +1,7 @@
 import { tsTypeGuards } from '../../assertions/equality/ts-type-equality.js';
 import { extendableAssertions } from '../../assertions/extendable-assertions.js';
 import { AssertionError } from '../assertion.error.js';
-const allAssertions = {
-    ...tsTypeGuards.assert,
-    ...extendableAssertions,
+const extraAssertions = {
     /**
      * Immediately throw an assertion error.
      *
@@ -21,6 +19,11 @@ const allAssertions = {
         throw new AssertionError('Failure triggered.', failureMessage);
     },
 };
+const allAssertions = {
+    ...tsTypeGuards.assert,
+    ...extendableAssertions,
+    ...extraAssertions,
+};
 /**
  * A group of guard methods that assert their conditions and do nothing else.
  *

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

@@ -1,258 +1,7 @@
-import { AnyFunction } from '@augment-vir/core';
-declare const checkWrapGroup: import("../../guard-types/check-wrap-wrapper-function.js").CheckWrapGroup<{
-    output: {
-        <const FunctionToCall extends 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 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: (actual: unknown, failureMessage?: string | undefined) => asserts actual is unknown[];
-    isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
-    isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
-    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, 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, 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("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").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("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").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) => import("../assertion-exports.js").Falsy<T> | undefined;
-    isTrue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isTruthy: <T>(input: T) => import("../assertion-exports.js").Truthy<T> | undefined;
-} & {
-    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;
-} & {
-    output: {
-        <const FunctionToCall extends 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 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>>> | undefined : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined> : Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined;
-    };
-} & {
-    isArray: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isBigInt: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isBoolean: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
-    isFunction: <const Actual>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, 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, 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;
-} & {
-    throws: {
-        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error | undefined;
-        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<Error | undefined>;
-        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.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("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error | undefined>;
-    };
-    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) => 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("../assertion-exports.js").CanBeEmpty>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty> | undefined;
-    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => Exclude<Actual, import("../assertion-exports.js").Empty> | undefined;
-} & {
-    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;
-    };
-} & {
-    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;
-} & {
-    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;
-} & {
-    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;
-} & {
-    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;
-} & {
-    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;
-} & {
-    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("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").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("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").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;
-} & {
-    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;
-    };
-} & {
-    isDefined: undefined;
-    isNullish: undefined;
-} & {
-    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) => 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;
-} & {
-    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;
-} & {
-    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> | undefined;
-}>;
+import { type AnyFunction } from '@augment-vir/core';
+import { checkWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
+import { CheckWrapGroup } from '../../guard-types/check-wrap-wrapper-function.js';
+declare const checkWrapGroup: CheckWrapGroup<typeof extendableAssertions, typeof checkWrapOverrides>;
 /**
  * A group of guard methods that do the following:
  *

package/dist/augments/guards/check-wrap.js

@@ -1,5 +1,5 @@
 import { checkWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
-import { createCheckWrapGroup } from '../../guard-types/check-wrap-wrapper-function.js';
+import { createCheckWrapGroup, } from '../../guard-types/check-wrap-wrapper-function.js';
 const checkWrapGroup = createCheckWrapGroup(extendableAssertions, checkWrapOverrides);
 /**
  * A group of guard methods that do the following: