@augment-vir/assert 30.0.0 → 30.0.2

package/dist/augments/assertion.error.d.ts

@@ -6,6 +6,7 @@
  * (the optional user-defined failure message for any assertion).
  *
  * @category Assert : Util
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -15,7 +16,7 @@
  * throw new AssertionError('The assertion failed.', 'User defined message.');
  * ```
  *
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
 export declare class AssertionError extends Error {
     name: string;

package/dist/augments/assertion.error.js

@@ -7,6 +7,7 @@ import { combineErrorMessages } from '@augment-vir/core';
  * (the optional user-defined failure message for any assertion).
  *
  * @category Assert : Util
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -16,7 +17,7 @@ import { combineErrorMessages } from '@augment-vir/core';
  * throw new AssertionError('The assertion failed.', 'User defined message.');
  * ```
  *
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
 export class AssertionError extends Error {
     name = 'AssertionError';

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

@@ -1,33 +1,4 @@
-/**
- * A group of guard methods that do the following:
- *
- * 1. Run the method's assertion on the given inputs.
- * 2. If the assertion fails, throws an error.
- * 3. If the assertion succeeds, the first input is returned and (when possible) type guarded.
- *
- * @category Assert
- * @example
- *
- * ```ts
- * import {assertWrap} from '@augment-vir/assert';
- *
- * // `result1` will be `['a']`
- * const result1 = assertWrap.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 = assertWrap.isString(value);
- *
- * const value2: unknown = 'some value' as unknown;
- * // this will throw an error
- * const result3 = assertWrap.isNumber(value2);
- * ```
- *
- * @returns The original value if expectations are met.
- * @throws {@link AssertionError} When the assertion fails.
- * @package @augment-vir/assert
- */
-export declare const assertWrap: import("../../guard-types/assert-wrap-function.js").AssertWrapGroup<{
+declare const assertWrapGroup: import("../../guard-types/assert-wrap-function.js").AssertWrapGroup<{
     output: {
         <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
         <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("../assertion-exports.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
@@ -44,13 +15,13 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
     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;
@@ -71,12 +42,12 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
     isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, bigint>;
     isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, boolean>;
     isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, number>;
     isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
     isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, string>;
     isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, symbol>;
     isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, undefined>;
-    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
@@ -140,24 +111,38 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
         (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, failureMessage?: string | undefined) => import("../assertion-exports.js").Falsy<T>;
+    isTrue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isTruthy: <T>(input: T, failureMessage?: string | undefined) => import("../assertion-exports.js").Truthy<T>;
 } & {
     strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+    notStrictEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    looseEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    notLooseEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+    notDeepEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
     output: {
         <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>>> : Awaited<ReturnType<NoInfer<FunctionToCall>>>;
         <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("../assertion-exports.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<FunctionToCall>> extends true ? Awaited<ReturnType<NoInfer<FunctionToCall>>> : Promise<Awaited<ReturnType<NoInfer<FunctionToCall>>>> : Awaited<ReturnType<NoInfer<FunctionToCall>>>;
     };
 } & {
+    isArray: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isBigInt: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isBoolean: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+    isNull: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isNumber: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isObject: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isString: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, symbol>;
+    isUndefined: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>>;
     isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint>;
     isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean>;
@@ -166,8 +151,8 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
     isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, number>;
     isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").UnknownObject>;
     isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, string>;
-    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
     isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol>;
+    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
 } & {
     throws: {
         (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
@@ -175,7 +160,12 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
         (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
         (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error>;
     };
+    isError: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
+    hasValue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    lacksValue: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    hasValues: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    lacksValues: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isIn: <const Child, const Parent>(child: Child, parent: Parent, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>>;
     isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, import("@augment-vir/core").Values<Parent>>;
     isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
@@ -206,9 +196,12 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
     isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
 } & {
     entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+    notEntriesEqual: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
     jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+    notJsonEquals: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
+    isHttpStatus: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
 } & {
     instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => Instance;
@@ -231,14 +224,66 @@ export declare const assertWrap: import("../../guard-types/assert-wrap-function.
     };
 } & {
     isDefined: <Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined | null>;
+    isNullish: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+} & {
+    isAbove: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isAtLeast: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isBelow: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isAtMost: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isNaN: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isFinite: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isInfinite: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isApproximately: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isNotApproximately: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
     isNotPrimitive: <const Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("type-fest").Primitive>;
     isNotPropertyKey: <const Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, PropertyKey>;
+    isPrimitive: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    isPropertyKey: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
-    isPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, Promise<any>>;
-    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>>;
     isPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, PromiseLike<any>>;
     isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, PromiseLike<any>>;
+    isPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Extract<Actual, Promise<any>>;
+    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, Promise<any>>;
+} & {
+    matches: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
+    mismatches: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
 } & {
+    isUuid: typeof import("../../guard-types/guard-override.js").autoGuardSymbol;
     isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").Uuid>;
 }>;
+/**
+ * A group of guard methods that do the following:
+ *
+ * 1. Run the method's assertion on the given inputs.
+ * 2. If the assertion fails, throws an error.
+ * 3. If the assertion succeeds, the first input is returned and (when possible) type guarded.
+ *
+ * This can also be called as a standalone assertion function which asserts that its input is truthy
+ * and returns it if so.
+ *
+ * @category Assert
+ * @category Package : @augment-vir/assert
+ * @example
+ *
+ * ```ts
+ * import {assertWrap} from '@augment-vir/assert';
+ *
+ * // `result1` will be `['a']`
+ * const result1 = assertWrap.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 = assertWrap.isString(value);
+ *
+ * const value2: unknown = 'some value' as unknown;
+ * // this will throw an error
+ * const result3 = assertWrap.isNumber(value2);
+ * ```
+ *
+ * @returns The original value if expectations are met.
+ * @throws {@link AssertionError} When the assertion fails.
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export declare const assertWrap: (<T>(input: T, failureMessage?: string | undefined) => T) & typeof assertWrapGroup;
+export {};

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

@@ -1,5 +1,7 @@
 import { assertWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
 import { createAssertWrapGroup } from '../../guard-types/assert-wrap-function.js';
+import { AssertionError } from '../assertion.error.js';
+const assertWrapGroup = createAssertWrapGroup(extendableAssertions, assertWrapOverrides);
 /**
  * A group of guard methods that do the following:
  *
@@ -7,7 +9,11 @@ import { createAssertWrapGroup } from '../../guard-types/assert-wrap-function.js
  * 2. If the assertion fails, throws an error.
  * 3. If the assertion succeeds, the first input is returned and (when possible) type guarded.
  *
+ * This can also be called as a standalone assertion function which asserts that its input is truthy
+ * and returns it if so.
+ *
  * @category Assert
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -27,6 +33,11 @@ import { createAssertWrapGroup } from '../../guard-types/assert-wrap-function.js
  *
  * @returns The original value if expectations are met.
  * @throws {@link AssertionError} When the assertion fails.
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export const assertWrap = createAssertWrapGroup(extendableAssertions, assertWrapOverrides);
+export const assertWrap = Object.assign(function assertWrap(input, failureMessage) {
+    if (!input) {
+        throw new AssertionError('Assertion failed.', failureMessage);
+    }
+    return input;
+}, assertWrapGroup);

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

@@ -1,9 +1,21 @@
-import type { AnyFunction } from '@augment-vir/core';
 declare const allAssertions: {
-    fail(failureMessage?: string | undefined): never;
+    /**
+     * Immediately throw an assertion error.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.fail(); // throws an `AssertionError`
+     * ```
+     *
+     * @throws {@link AssertionError}
+     */
+    fail: (failureMessage?: string | undefined) => never;
     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;
+        <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>>;
@@ -17,13 +29,13 @@ declare const allAssertions: {
     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;
@@ -33,7 +45,7 @@ declare const allAssertions: {
     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>;
+    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;
@@ -43,13 +55,13 @@ declare const allAssertions: {
     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>;
+    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, number>;
     isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").UnknownObject>;
     isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, string>;
     isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, symbol>;
     isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, undefined>;
-    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, null>;
     matches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     mismatches: (actual: string, expected: RegExp, failureMessage?: string | undefined) => void;
     isPromiseLike: (actual: unknown, failureMessage?: string | undefined) => asserts actual is PromiseLike<any>;
@@ -81,9 +93,9 @@ declare const allAssertions: {
     };
     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>;
+    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("@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>;
+    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;
@@ -113,10 +125,10 @@ declare const allAssertions: {
         (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>;
     tsType: {
         <Actual>(input: Actual): {
             equals: {
@@ -159,7 +171,11 @@ declare const allAssertions: {
 /**
  * A group of guard methods that assert their conditions and do nothing else.
  *
+ * This can also be called as a standalone assertion function which asserts that its input is
+ * truthy.
+ *
  * @category Assert
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -171,7 +187,7 @@ declare const allAssertions: {
  * ```
  *
  * @throws {@link AssertionError} When the assertion fails.
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export declare const assert: ((input: unknown, failureMessage?: string | undefined) => void) & typeof allAssertions & Record<keyof AnyFunction, never>;
+export declare const assert: ((input: unknown, failureMessage?: string | undefined) => void) & typeof allAssertions;
 export {};

package/dist/augments/guards/assert.js

@@ -2,16 +2,33 @@ 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.assertions,
+    ...tsTypeGuards.assert,
     ...extendableAssertions,
-    fail(failureMessage) {
+    /**
+     * Immediately throw an assertion error.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.fail(); // throws an `AssertionError`
+     * ```
+     *
+     * @throws {@link AssertionError}
+     */
+    fail: (failureMessage) => {
         throw new AssertionError('Failure triggered.', failureMessage);
     },
 };
 /**
  * A group of guard methods that assert their conditions and do nothing else.
  *
+ * This can also be called as a standalone assertion function which asserts that its input is
+ * truthy.
+ *
  * @category Assert
+ * @category Package : @augment-vir/assert
  * @example
  *
  * ```ts
@@ -23,9 +40,9 @@ const allAssertions = {
  * ```
  *
  * @throws {@link AssertionError} When the assertion fails.
- * @package @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
  */
-export const assert = Object.assign((input, failureMessage) => {
+export const assert = Object.assign(function assert(input, failureMessage) {
     if (!input) {
         throw new AssertionError('Assertion failed.', failureMessage);
     }