@augment-vir/assert 30.0.0

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

@@ -0,0 +1,244 @@
+/**
+ * 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<{
+    output: {
+        <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
+        <const FunctionToCall extends import("@augment-vir/core").AnyFunction>(asserter: import("../assertion-exports.js").CustomOutputAsserter<NoInfer<FunctionToCall>>, functionToCall: FunctionToCall, inputs: Parameters<NoInfer<FunctionToCall>>, expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>, failureMessage?: string | undefined): Promise<any> extends ReturnType<NoInfer<FunctionToCall>> ? import("type-fest").IsAny<ReturnType<NoInfer<FunctionToCall>>> extends true ? void : Promise<void> : void;
+    };
+    isHttpStatus: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").HttpStatus;
+    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
+    hasValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
+    lacksValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
+    hasValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
+    lacksValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
+    isIn: typeof import("../../assertions/values.js").isIn;
+    isNotIn: <const Parent extends object | string, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => asserts child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
+    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
+    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("../assertion-exports.js").Empty>;
+    isUuid: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").Uuid;
+    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
+    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>;
+    };
+    strictEquals: typeof import("../../assertions/equality/simple-equality.js").strictEquals;
+    notStrictEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    looseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    notLooseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    deepEquals: typeof import("../../assertions/equality/simple-equality.js").deepEquals;
+    notDeepEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    isArray: (actual: unknown, failureMessage?: string | undefined) => asserts actual is unknown[];
+    isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
+    isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
+    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+    isNull: (actual: unknown, failureMessage?: string | undefined) => asserts actual is null;
+    isNumber: (actual: unknown, failureMessage?: string | undefined) => asserts actual is number;
+    isObject: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").UnknownObject;
+    isString: (actual: unknown, failureMessage?: string | undefined) => asserts actual is string;
+    isSymbol: (actual: unknown, failureMessage?: string | undefined) => asserts actual is symbol;
+    isUndefined: (actual: unknown, failureMessage?: string | undefined) => asserts actual is undefined;
+    isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
+    isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, bigint>;
+    isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, boolean>;
+    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+    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>;
+    isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, PromiseLike<any>>;
+    isPromise: (actual: unknown, failureMessage?: string | undefined) => asserts actual is Promise<any>;
+    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, Promise<any>>;
+    isPropertyKey: (input: unknown, failureMessage?: string | undefined) => asserts input is PropertyKey;
+    isNotPropertyKey: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, PropertyKey>;
+    isPrimitive: (input: unknown, failureMessage?: string | undefined) => asserts input is import("type-fest").Primitive;
+    isNotPrimitive: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, import("type-fest").Primitive>;
+    isAbove: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isAtLeast: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isBelow: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isAtMost: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isNaN: (actual: number, failureMessage?: string | undefined) => void;
+    isFinite: (actual: number, failureMessage?: string | undefined) => void;
+    isInfinite: (actual: number, failureMessage?: string | undefined) => void;
+    isApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
+    isNotApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
+    isDefined: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, undefined | null>;
+    isNullish: (input: unknown, failureMessage?: string | undefined) => asserts input is null | undefined;
+    isLengthAtLeast: {
+        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
+        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
+    };
+    isLengthExactly: {
+        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").Tuple<Element, Length>;
+        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
+    };
+    isKeyOf: <const Parent>(key: PropertyKey, parent: Parent, failureMessage?: string | undefined) => asserts key is keyof Parent;
+    isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => asserts key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
+    hasKey: <const Key extends PropertyKey, const Parent>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
+    lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Record<Key, any>>;
+    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => asserts parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
+    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
+    jsonEquals: <const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
+    notJsonEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Instance;
+    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Exclude<Actual, Instance>;
+    isEnumValue: typeof import("../../assertions/enum.js").isEnumValue;
+    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => asserts child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
+    entriesEqual: <const Actual extends object, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
+    notEntriesEqual: (actual: object, expected: object, failureMessage?: string | undefined) => void;
+    endsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    endsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    startsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    startsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    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;
+}, {
+    isFalsy: <T>(input: T, failureMessage?: string | undefined) => import("../assertion-exports.js").Falsy<T>;
+    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>;
+    deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+} & {
+    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>>>;
+    };
+} & {
+    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+    isSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, symbol>;
+    isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>>;
+    isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint>;
+    isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean>;
+    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").AnyFunction>;
+    isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, null>;
+    isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, number>;
+    isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").UnknownObject>;
+    isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, string>;
+    isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
+    isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol>;
+} & {
+    throws: {
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<Error>;
+        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error;
+        (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error>;
+    };
+} & {
+    isIn: <const Child, const Parent>(child: Child, parent: Parent, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>>;
+    isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, import("@augment-vir/core").Values<Parent>>;
+    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
+    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => Exclude<Actual, import("../assertion-exports.js").Empty>;
+} & {
+    endsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
+    };
+    endsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
+    };
+    startsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
+    };
+    startsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent;
+    };
+} & {
+    isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]>;
+    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
+} & {
+    entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+} & {
+    jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, Expected>;
+} & {
+    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
+} & {
+    instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => Instance;
+    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => Exclude<Actual, Instance>;
+} & {
+    isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Key, keyof Parent>;
+    isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
+    hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Parent & Record<Key, (Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("type-fest").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
+    lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => Exclude<Parent, Record<Key, any>>;
+    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => Parent & Record<Keys, (Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("type-fest").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("type-fest").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
+    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>, failureMessage?: string | undefined) => Exclude<Parent, Partial<Record<Key, any>>>;
+} & {
+    isLengthAtLeast: {
+        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").AtLeastTuple<Element, Length>;
+        <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual;
+    };
+    isLengthExactly: {
+        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").Tuple<Element, Length>;
+        <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual;
+    };
+} & {
+    isDefined: <Actual>(input: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined | null>;
+} & {
+    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>;
+} & {
+    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>>;
+} & {
+    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, import("@augment-vir/core").Uuid>;
+}>;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import { assertWrap } from '@augment-vir/assert';
+// `result1` will be `['a']`
+const result1 = assertWrap.deepEquals(['a'], ['a']);
+const value = 'some value';
+// `result2` will be `'some value'` and it will have the type of `string`
+const result2 = assertWrap.isString(value);
+const value2 = 'some value';
+// this will throw an error
+const result3 = assertWrap.isNumber(value2);

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

@@ -0,0 +1,32 @@
+import { assertWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
+import { createAssertWrapGroup } from '../../guard-types/assert-wrap-function.js';
+/**
+ * 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 const assertWrap = createAssertWrapGroup(extendableAssertions, assertWrapOverrides);

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

@@ -0,0 +1,177 @@
+import type { AnyFunction } from '@augment-vir/core';
+declare const allAssertions: {
+    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;
+    };
+    isHttpStatus: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").HttpStatus;
+    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>>;
+    hasValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
+    lacksValue: (parent: object, value: unknown, failureMessage?: string | undefined) => void;
+    hasValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
+    lacksValues: (parent: object, values: ReadonlyArray<unknown>, failureMessage?: string | undefined) => void;
+    isIn: typeof import("../../assertions/values.js").isIn;
+    isNotIn: <const Parent extends object | string, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => asserts child is Exclude<Child, import("@augment-vir/core").Values<Parent>>;
+    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty>;
+    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("../assertion-exports.js").Empty>;
+    isUuid: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").Uuid;
+    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
+    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>;
+    };
+    strictEquals: typeof import("../../assertions/equality/simple-equality.js").strictEquals;
+    notStrictEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    looseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    notLooseEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    deepEquals: typeof import("../../assertions/equality/simple-equality.js").deepEquals;
+    notDeepEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    isArray: (actual: unknown, failureMessage?: string | undefined) => asserts actual is unknown[];
+    isBigInt: (actual: unknown, failureMessage?: string | undefined) => asserts actual is bigint;
+    isBoolean: (actual: unknown, failureMessage?: string | undefined) => asserts actual is boolean;
+    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").NarrowToActual<Actual, AnyFunction>;
+    isNull: (actual: unknown, failureMessage?: string | undefined) => asserts actual is null;
+    isNumber: (actual: unknown, failureMessage?: string | undefined) => asserts actual is number;
+    isObject: (actual: unknown, failureMessage?: string | undefined) => asserts actual is import("@augment-vir/core").UnknownObject;
+    isString: (actual: unknown, failureMessage?: string | undefined) => asserts actual is string;
+    isSymbol: (actual: unknown, failureMessage?: string | undefined) => asserts actual is symbol;
+    isUndefined: (actual: unknown, failureMessage?: string | undefined) => asserts actual is undefined;
+    isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
+    isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, bigint>;
+    isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, boolean>;
+    isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, AnyFunction>;
+    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>;
+    isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, PromiseLike<any>>;
+    isPromise: (actual: unknown, failureMessage?: string | undefined) => asserts actual is Promise<any>;
+    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => asserts actual is Exclude<Actual, Promise<any>>;
+    isPropertyKey: (input: unknown, failureMessage?: string | undefined) => asserts input is PropertyKey;
+    isNotPropertyKey: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, PropertyKey>;
+    isPrimitive: (input: unknown, failureMessage?: string | undefined) => asserts input is import("type-fest").Primitive;
+    isNotPrimitive: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, import("type-fest").Primitive>;
+    isAbove: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isAtLeast: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isBelow: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isAtMost: (actual: number, expected: number, failureMessage?: string | undefined) => void;
+    isNaN: (actual: number, failureMessage?: string | undefined) => void;
+    isFinite: (actual: number, failureMessage?: string | undefined) => void;
+    isInfinite: (actual: number, failureMessage?: string | undefined) => void;
+    isApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
+    isNotApproximately: (actual: number, expected: number, delta: number, failureMessage?: string | undefined) => void;
+    isDefined: <const Actual>(input: Actual, failureMessage?: string | undefined) => asserts input is Exclude<Actual, undefined | null>;
+    isNullish: (input: unknown, failureMessage?: string | undefined) => asserts input is null | undefined;
+    isLengthAtLeast: {
+        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
+        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
+    };
+    isLengthExactly: {
+        <const Element, const Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length, failureMessage?: string | undefined): asserts actual is import("@augment-vir/core").Tuple<Element, Length>;
+        (actual: string | import("@augment-vir/core").AnyObject, length: number, failureMessage?: string | undefined): void;
+    };
+    isKeyOf: <const Parent>(key: PropertyKey, parent: Parent, failureMessage?: string | undefined) => asserts key is keyof Parent;
+    isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => asserts key is Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>>;
+    hasKey: <const Key extends PropertyKey, const Parent>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Parent & Record<Key, (Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never) extends never ? unknown : Key extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Key>[Key] : Key extends keyof Extract<Parent, Record<Key, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never>;
+    lacksKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Record<Key, any>>;
+    hasKeys: <const Keys extends PropertyKey, const Parent>(parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined) => asserts parent is Parent & Record<Keys, (Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never) extends never ? unknown : Keys extends keyof Parent ? import("@augment-vir/core").SetRequired<Parent, Keys>[Keys] : Keys extends keyof Extract<Parent, Record<Keys, any>> ? import("@augment-vir/core").SetRequired<Extract<Parent, Record<Keys, any>>, Keys>[Keys] : never>;
+    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined) => asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
+    jsonEquals: <const Actual, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
+    notJsonEquals: (actual: unknown, expected: unknown, failureMessage?: string | undefined) => void;
+    instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Instance;
+    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>, failureMessage?: string | undefined) => asserts instance is Exclude<Actual, Instance>;
+    isEnumValue: typeof import("../../assertions/enum.js").isEnumValue;
+    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected, failureMessage?: string | undefined) => asserts child is Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>;
+    entriesEqual: <const Actual extends object, const Expected extends Actual>(actual: Actual, expected: Expected, failureMessage?: string | undefined) => asserts actual is Expected;
+    notEntriesEqual: (actual: object, expected: object, failureMessage?: string | undefined) => void;
+    endsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    endsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    startsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    startsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): void;
+        (parent: string, child: string, failureMessage?: string | undefined): void;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): void;
+    };
+    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;
+    tsType: {
+        <Actual>(input: Actual): {
+            equals: {
+                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
+                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
+            };
+            notEquals: {
+                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
+                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
+            };
+            matches: {
+                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
+                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
+            };
+            notMatches: {
+                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
+                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
+            };
+        };
+        <Actual>(): {
+            equals: {
+                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
+                <Expected extends import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, true>): true;
+            };
+            notEquals: {
+                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
+                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").StrictEqualUsingTSInternalIdenticalToOperator<Actual, Expected>, false>): true;
+            };
+            matches: {
+                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
+                <Expected extends import("expect-type").Extends<Actual, Expected> extends true ? unknown : import("expect-type").MismatchInfo<Actual, Expected>>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, true>): true;
+            };
+            notMatches: {
+                <Expected>(value: Expected & import("expect-type").AValue, ...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
+                <Expected>(...MISMATCH: import("expect-type").MismatchArgs<import("expect-type").Extends<Actual, Expected>, false>): true;
+            };
+        };
+    };
+};
+/**
+ * A group of guard methods that assert their conditions and do nothing else.
+ *
+ * @category Assert
+ * @example
+ *
+ * ```ts
+ * import {assert} from '@augment-vir/assert';
+ *
+ * const value: unknown = 'some value' as unknown;
+ * assert.isString(value);
+ * // `value` will now be typed as a `string`
+ * ```
+ *
+ * @throws {@link AssertionError} When the assertion fails.
+ * @package @augment-vir/assert
+ */
+export declare const assert: ((input: unknown, failureMessage?: string | undefined) => void) & typeof allAssertions & Record<keyof AnyFunction, never>;
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/augments/guards/assert.example.js

@@ -0,0 +1,4 @@
+import { assert } from '@augment-vir/assert';
+const value = 'some value';
+assert.isString(value);
+// `value` will now be typed as a `string`

package/dist/augments/guards/assert.js

@@ -0,0 +1,32 @@
+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,
+    ...extendableAssertions,
+    fail(failureMessage) {
+        throw new AssertionError('Failure triggered.', failureMessage);
+    },
+};
+/**
+ * A group of guard methods that assert their conditions and do nothing else.
+ *
+ * @category Assert
+ * @example
+ *
+ * ```ts
+ * import {assert} from '@augment-vir/assert';
+ *
+ * const value: unknown = 'some value' as unknown;
+ * assert.isString(value);
+ * // `value` will now be typed as a `string`
+ * ```
+ *
+ * @throws {@link AssertionError} When the assertion fails.
+ * @package @augment-vir/assert
+ */
+export const assert = Object.assign((input, failureMessage) => {
+    if (!input) {
+        throw new AssertionError('Assertion failed.', failureMessage);
+    }
+}, allAssertions);