@augment-vir/assert 30.0.0 → 30.0.2

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

@@ -1,38 +1,8 @@
-/**
- * A group of guard methods that do the following:
- *
- * 1. Run the method's assertion on the given inputs.
- * 2. If the assertion fails, return `undefined`.
- * 3. If the assertion succeeds, the first input is returned and (when possible) type guarded.
- *
- * This is a combination of {@link assertWrap} and {@link check}.
- *
- * @category Assert
- * @example
- *
- * ```ts
- * import {checkWrap} from '@augment-vir/assert';
- *
- * // `result1` will be `['a']`
- * const result1 = checkWrap.deepEquals(['a'], ['a']);
- *
- * const value: unknown = 'some value' as unknown;
- * // `result2` will be `'some value'` and it will have the type of `string`
- * const result2 = checkWrap.isString(value);
- *
- * const value2: unknown = 'some value' as unknown;
- * // `result` will be `undefined`
- * const result3 = checkWrap.isNumber(value2);
- * ```
- *
- * @returns The original given value (type guarded when possible) or, if the expectation fails,
- *   `undefined`.
- * @package @augment-vir/assert
- */
-export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-function.js").CheckWrapGroup<{
+import { AnyFunction } from '@augment-vir/core';
+declare const checkWrapGroup: import("../../guard-types/check-wrap-wrapper-function.js").CheckWrapGroup<{
     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;
+        <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>>;
@@ -46,13 +16,13 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
     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>;
-    isError: (actual: unknown, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
     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;
@@ -62,7 +32,7 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
     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>;
+    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;
@@ -72,13 +42,13 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
     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>;
+    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>;
-    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
@@ -110,9 +80,9 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
     };
     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>;
+    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("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>;
+    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;
@@ -142,34 +112,48 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
         (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;
-    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("../assertion-exports.js").Truthy<Actual>;
     isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-    isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
+    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("../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 import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined> : Awaited<ReturnType<NoInfer<FunctionToCall>>> | undefined;
-        <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("../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;
+        <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;
     };
 } & {
-    isFunction: <const Actual>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction> | 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;
-    isNotUndefined: undefined;
     isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>> | undefined;
     isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint> | undefined;
     isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean> | undefined;
-    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").AnyFunction> | 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;
@@ -177,7 +161,12 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
         (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;
@@ -208,9 +197,12 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
     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;
@@ -218,9 +210,9 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
 } & {
     isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent) => import("@augment-vir/core").NarrowToExpected<Key, keyof Parent> | undefined;
     isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>> | undefined;
-    hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => (Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>) | undefined;
+    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("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>) | undefined;
+    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: {
@@ -234,14 +226,65 @@ export declare const checkWrap: import("../../guard-types/check-wrap-wrapper-fun
 } & {
     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;
 }>;
-/** Type of {@link checkWrap}. */
-export type CheckWrap = typeof checkWrap;
+/**
+ * A group of guard methods that do the following:
+ *
+ * 1. Run the method's assertion on the given inputs.
+ * 2. If the assertion fails, return `undefined`.
+ * 3. If the assertion succeeds, the first input is returned and (when possible) type guarded.
+ *
+ * This can also be called as a standalone check function which checks that its input is truthy and
+ * returns it if so, else `undefined`.
+ *
+ * @category Assert
+ * @category Package : @augment-vir/assert
+ * @example
+ *
+ * ```ts
+ * import {checkWrap} from '@augment-vir/assert';
+ *
+ * // `result1` will be `['a']`
+ * const result1 = checkWrap.deepEquals(['a'], ['a']);
+ *
+ * const value: unknown = 'some value' as unknown;
+ * // `result2` will be `'some value'` and it will have the type of `string`
+ * const result2 = checkWrap.isString(value);
+ *
+ * const value2: unknown = 'some value' as unknown;
+ * // `result` will be `undefined`
+ * const result3 = checkWrap.isNumber(value2);
+ * ```
+ *
+ * @returns The original given value (type guarded when possible) or, if the expectation fails,
+ *   `undefined`.
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export declare const checkWrap: (<T>(input: T) => undefined | T) & typeof checkWrapGroup & Record<keyof AnyFunction, never>;
+export {};

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

@@ -1,5 +1,6 @@
 import { checkWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.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:
  *
@@ -7,9 +8,11 @@ import { createCheckWrapGroup } from '../../guard-types/check-wrap-wrapper-funct
  * 2. If the assertion fails, return `undefined`.
  * 3. If the assertion succeeds, the first input is returned and (when possible) type guarded.
  *
- * This is a combination of {@link assertWrap} and {@link check}.
+ * This can also be called as a standalone check function which checks that its input is truthy and
+ * returns it if so, else `undefined`.
  *
  * @category Assert
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -29,6 +32,11 @@ import { createCheckWrapGroup } from '../../guard-types/check-wrap-wrapper-funct
  *
  * @returns The original given value (type guarded when possible) or, if the expectation fails,
  *   `undefined`.
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export const checkWrap = createCheckWrapGroup(extendableAssertions, checkWrapOverrides);
+export const checkWrap = Object.assign(function checkWrap(input) {
+    if (!input) {
+        return undefined;
+    }
+    return input;
+}, checkWrapGroup);

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

@@ -1,25 +1,8 @@
-/**
- * A group of guard methods that return a boolean type guard rather than an assertion type guard.
- *
- * @category Assert
- * @example
- *
- * ```ts
- * import {check} from '@augment-vir/assert';
- *
- * const value: unknown = 'some value' as unknown;
- * if (check.isString(value)) {
- *     // `value` will now be typed as a `string` in here
- * }
- * ```
- *
- * @returns A boolean (as a type guard when possible).
- * @package @augment-vir/assert
- */
-export declare const check: import("../../guard-types/check-function.js").CheckGroup<{
+import { AnyFunction } from '@augment-vir/core';
+declare const checkGroup: import("../../guard-types/check-function.js").CheckGroup<{
     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;
+        <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>>;
@@ -33,13 +16,13 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
     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>;
-    isError: (actual: unknown, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined) => asserts actual is Error;
     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;
@@ -49,7 +32,7 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
     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>;
+    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;
@@ -59,13 +42,13 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
     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>;
+    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>;
-    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
@@ -97,9 +80,9 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
     };
     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>;
+    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("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>;
+    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;
@@ -129,32 +112,48 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
         (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;
-    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("../assertion-exports.js").Truthy<Actual>;
     isTrue: (input: unknown, failureMessage?: string | undefined) => asserts input is true;
-    isFalse: (input: unknown, failureMessage?: string | undefined) => asserts input is false;
+    isTruthy: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is import("../assertion-exports.js").Truthy<Actual>;
 }, {
+    isFalse: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isFalsy: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isTrue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isTruthy: <T>(input: T) => input is import("../assertion-exports.js").Truthy<T>;
 } & {
     strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+    notStrictEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    looseEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    notLooseEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+    notDeepEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
     output: {
-        <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? boolean : Promise<boolean> : boolean;
-        <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("../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 ? boolean : Promise<boolean> : boolean;
+        <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 ? boolean : Promise<boolean> : boolean;
+        <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 ? boolean : Promise<boolean> : boolean;
     };
 } & {
-    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+    isArray: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isBigInt: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isBoolean: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToActual<Actual, AnyFunction>;
+    isNull: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isNumber: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isObject: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isString: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isSymbol: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isUndefined: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, ReadonlyArray<unknown>>;
     isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, bigint>;
     isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, boolean>;
-    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, AnyFunction>;
     isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, null>;
     isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, number>;
     isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
     isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, string>;
-    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, undefined>;
     isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, symbol>;
+    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, undefined>;
 } & {
     throws: {
         (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): boolean;
@@ -162,7 +161,12 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
         (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): boolean;
         (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): import("@augment-vir/core").MaybePromise<boolean>;
     };
+    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 Parent>(child: unknown, parent: Parent) => child is import("@augment-vir/core").Values<Parent>;
     isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
     isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => actual is import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
@@ -193,9 +197,12 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
     isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
 } & {
     entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+    notEntriesEqual: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
     jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is 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) => actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
 } & {
     instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>) => instance is Instance;
@@ -203,9 +210,9 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
 } & {
     isKeyOf: <const Parent>(key: PropertyKey, parent: Parent) => key is keyof Parent;
     isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
-    hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => parent is Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
+    hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => 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) => parent is Exclude<Parent, Record<Key, any>>;
-    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
+    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>) => 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, key: ReadonlyArray<Key>) => parent is Exclude<Parent, Partial<Record<Key, any>>>;
 } & {
     isLengthAtLeast: {
@@ -218,12 +225,55 @@ export declare const check: import("../../guard-types/check-function.js").CheckG
     };
 } & {
     isDefined: <Actual>(input: Actual) => input is 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) => input is Exclude<Actual, import("type-fest").Primitive>;
     isNotPropertyKey: <const Actual>(input: Actual) => input is Exclude<Actual, PropertyKey>;
+    isPrimitive: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isPropertyKey: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
-    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
+    isPromiseLike: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, PromiseLike<any>>;
+    isPromise: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
+} & {
+    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) => actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
 }>;
+/**
+ * A group of guard methods that return a boolean type guard rather than an assertion type guard.
+ *
+ * This can also be called as a standalone check function which returns a boolean to indicate
+ * whether its input is truthy or not.
+ *
+ * @category Assert
+ * @category Package : @augment-vir/assert
+ * @example
+ *
+ * ```ts
+ * import {check} from '@augment-vir/assert';
+ *
+ * const value: unknown = 'some value' as unknown;
+ * if (check.isString(value)) {
+ *     // `value` will now be typed as a `string` in here
+ * }
+ * ```
+ *
+ * @returns A boolean (as a type guard when possible).
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export declare const check: ((input: unknown) => boolean) & typeof checkGroup & Record<keyof AnyFunction, never>;
+export {};

package/dist/augments/guards/check.js

@@ -1,9 +1,14 @@
 import { checkOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
 import { createCheckGroup } from '../../guard-types/check-function.js';
+const checkGroup = createCheckGroup(extendableAssertions, checkOverrides);
 /**
  * A group of guard methods that return a boolean type guard rather than an assertion type guard.
  *
+ * This can also be called as a standalone check function which returns a boolean to indicate
+ * whether its input is truthy or not.
+ *
  * @category Assert
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -16,6 +21,8 @@ import { createCheckGroup } from '../../guard-types/check-function.js';
  * ```
  *
  * @returns A boolean (as a type guard when possible).
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export const check = createCheckGroup(extendableAssertions, checkOverrides);
+export const check = Object.assign(function check(input) {
+    return !!input;
+}, checkGroup);