@augment-vir/assert 30.0.0

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

@@ -0,0 +1,247 @@
+/**
+ * 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<{
+    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) => import("../assertion-exports.js").Falsy<T> | undefined;
+    isTruthy: <T>(input: T) => import("../assertion-exports.js").Truthy<T> | undefined;
+} & {
+    strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => Expected | undefined;
+    deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected> | undefined;
+} & {
+    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;
+    };
+} & {
+    isFunction: <const Actual>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction> | undefined;
+    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;
+    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;
+} & {
+    throws: {
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error | undefined;
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Promise<Error | undefined>;
+        (callback: import("@augment-vir/core").TypedFunction<void, any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): Error | undefined;
+        (callback: import("@augment-vir/core").TypedFunction<void, import("@augment-vir/core").MaybePromise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined, failureMessage?: string | undefined): import("@augment-vir/core").MaybePromise<Error | undefined>;
+    };
+} & {
+    isIn: <const Child, const Parent>(child: Child, parent: Parent) => import("@augment-vir/core").NarrowToExpected<Child, import("@augment-vir/core").Values<Parent>> | undefined;
+    isNotIn: <const Parent, const Child>(child: Child, parent: Parent, failureMessage?: string | undefined) => Exclude<Child, import("@augment-vir/core").Values<Parent>> | undefined;
+    isEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => import("@augment-vir/core").NarrowToActual<Actual, import("../assertion-exports.js").Empty> | undefined;
+    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => Exclude<Actual, import("../assertion-exports.js").Empty> | undefined;
+} & {
+    endsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+    };
+    endsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+    };
+    startsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+    };
+    startsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): typeof parent | undefined;
+    };
+} & {
+    isEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected[keyof Expected]> | undefined;
+    isNotEnumValue: <const Actual, const Expected extends import("@augment-vir/core").EnumBaseType>(child: Actual, checkEnum: Expected) => Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`> | undefined;
+} & {
+    entriesEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected> | undefined;
+} & {
+    jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => import("@augment-vir/core").NarrowToExpected<Actual, Expected> | undefined;
+} & {
+    isHttpStatusCategory: <const Actual, const Category extends import("@augment-vir/core").HttpStatusCategory>(actual: Actual, category: Category, failureMessage?: string | undefined) => import("@augment-vir/core").NarrowToExpected<Actual, import("@augment-vir/core").HttpStatusByCategory<Category>> | undefined;
+} & {
+    instanceOf: <const Instance>(instance: unknown, constructor: import("type-fest").Constructor<Instance>) => Instance | undefined;
+    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>) => Exclude<Actual, Instance> | undefined;
+} & {
+    isKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent) => import("@augment-vir/core").NarrowToExpected<Key, keyof Parent> | undefined;
+    isNotKeyOf: <const Key extends PropertyKey, const Parent>(key: Key, parent: Parent, failureMessage?: string | undefined) => Exclude<Key, import("@augment-vir/core").RequiredKeysOf<Parent>> | undefined;
+    hasKey: <const Parent, const Key extends PropertyKey>(parent: Parent, key: Key) => (Parent & Record<Key, (Key extends keyof Parent ? import("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;
+    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;
+    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => Exclude<Parent, Partial<Record<Key, any>>> | undefined;
+} & {
+    isLengthAtLeast: {
+        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").AtLeastTuple<Element, Length> | undefined;
+        <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual | undefined;
+    };
+    isLengthExactly: {
+        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): import("@augment-vir/core").Tuple<Element, Length> | undefined;
+        <Actual extends string | import("@augment-vir/core").AnyObject>(actual: Actual, length: number): Actual | undefined;
+    };
+} & {
+    isDefined: undefined;
+    isNullish: undefined;
+} & {
+    isNotPrimitive: <const Actual>(input: Actual) => Exclude<Actual, import("type-fest").Primitive> | undefined;
+    isNotPropertyKey: <const Actual>(input: Actual) => Exclude<Actual, PropertyKey> | undefined;
+} & {
+    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;
+} & {
+    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;

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

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

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

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

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

@@ -0,0 +1,34 @@
+import { checkWrapOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
+import { createCheckWrapGroup } from '../../guard-types/check-wrap-wrapper-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, 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 const checkWrap = createCheckWrapGroup(extendableAssertions, checkWrapOverrides);

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

@@ -0,0 +1,229 @@
+/**
+ * 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<{
+    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;
+}, {
+    isTruthy: <T>(input: T) => input is import("../assertion-exports.js").Truthy<T>;
+} & {
+    strictEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+    deepEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is 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 ? 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;
+    };
+} & {
+    isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is import("@augment-vir/core").NarrowToActual<Actual, import("@augment-vir/core").AnyFunction>;
+    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>;
+    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>;
+} & {
+    throws: {
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, never>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): boolean;
+        (callbackOrPromise: import("@augment-vir/core").TypedFunction<void, Promise<any>> | Promise<any>, matchOptions?: import("../assertion-exports.js").ErrorMatchOptions | undefined): Promise<boolean>;
+        (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>;
+    };
+} & {
+    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>;
+    isNotEmpty: <const Actual extends import("../assertion-exports.js").CanBeEmpty>(actual: Actual) => actual is Exclude<Actual, import("../assertion-exports.js").Empty>;
+} & {
+    endsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
+        (parent: string, child: string, failureMessage?: string | undefined): boolean;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
+    };
+    endsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
+        (parent: string, child: string, failureMessage?: string | undefined): boolean;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
+    };
+    startsWith: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
+        (parent: string, child: string, failureMessage?: string | undefined): boolean;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
+    };
+    startsWithout: {
+        <const ArrayElement>(parent: ReadonlyArray<ArrayElement>, child: ArrayElement, failureMessage?: string | undefined): boolean;
+        (parent: string, child: string, failureMessage?: string | undefined): boolean;
+        (parent: string | ReadonlyArray<string>, child: string, failureMessage?: string | undefined): boolean;
+    };
+} & {
+    isEnumValue: <const Expected extends import("@augment-vir/core").EnumBaseType>(child: unknown, checkEnum: Expected) => child is Expected[keyof Expected];
+    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;
+} & {
+    jsonEquals: <Actual, Expected extends Actual>(actual: Actual, expected: Expected) => actual is Expected;
+} & {
+    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;
+    notInstanceOf: <const Actual, const Instance>(instance: Actual, constructor: import("type-fest").Constructor<Instance>) => instance is Exclude<Actual, Instance>;
+} & {
+    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>;
+    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>;
+    lacksKeys: <const Parent, const Key extends PropertyKey>(parent: Parent, key: ReadonlyArray<Key>) => parent is Exclude<Parent, Partial<Record<Key, any>>>;
+} & {
+    isLengthAtLeast: {
+        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is import("@augment-vir/core").AtLeastTuple<Element, Length>;
+        (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
+    };
+    isLengthExactly: {
+        <Element, Length extends number>(actual: ReadonlyArray<Element | undefined>, length: Length): actual is import("@augment-vir/core").Tuple<Element, Length>;
+        (actual: string | import("@augment-vir/core").AnyObject, length: number): boolean;
+    };
+} & {
+    isDefined: <Actual>(input: Actual) => input is Exclude<Actual, undefined | null>;
+} & {
+    isNotPrimitive: <const Actual>(input: Actual) => input is Exclude<Actual, import("type-fest").Primitive>;
+    isNotPropertyKey: <const Actual>(input: Actual) => input is Exclude<Actual, PropertyKey>;
+} & {
+    isNotPromise: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, Promise<any>>;
+    isNotPromiseLike: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, PromiseLike<any>>;
+} & {
+    isNotUuid: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, import("@augment-vir/core").Uuid>;
+}>;

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

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

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

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

package/dist/augments/guards/check.js

@@ -0,0 +1,21 @@
+import { checkOverrides, extendableAssertions } from '../../assertions/extendable-assertions.js';
+import { createCheckGroup } from '../../guard-types/check-function.js';
+/**
+ * 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 const check = createCheckGroup(extendableAssertions, checkOverrides);