Function checkWrap

A group of guard methods that do the following:

Run the method's assertion on the given inputs.
If the assertion fails, return undefined.
If the assertion succeeds, the first input is returned and (when possible) type guarded.

This can also be called as a standalone check function which checks that its input is truthy and returns it if so, else undefined.

Example

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);

Package

@augment-vir/assert

checkWrap<T>(input: T): undefined | T
Type Parameters
- T
Parameters
- input: T
Returns undefined | T
The original given value (type guarded when possible) or, if the expectation fails, undefined.
- Defined in packages/assert/src/augments/guards/check-wrap.ts:47

Index

Properties

endsWith endsWithout isDefined isLengthAtLeast isLengthExactly isNullish output startsWith startsWithout throws

Methods

deepEquals entriesEqual hasKey hasKeys hasValue hasValues instanceOf isAbove isApproximately isArray isAtLeast isAtMost isBelow isBigInt isBoolean isEmpty isEnumValue isError isFalse isFalsy isFinite isFunction isHttpStatus isHttpStatusCategory isIn isInBounds isInfinite isInteger isKeyOf isNaN isNotApproximately isNotArray isNotBigInt isNotBoolean isNotEmpty isNotEnumValue isNotFunction isNotIn isNotInteger isNotKeyOf isNotNull isNotNumber isNotObject isNotPrimitive isNotPromise isNotPromiseLike isNotPropertyKey isNotString isNotSymbol isNotUuid isNull isNumber isObject isOutBounds isPrimitive isPromise isPromiseLike isPropertyKey isString isSymbol isTrue isTruthy isUuid jsonEquals lacksKey lacksKeys lacksValue lacksValues looseEquals matches mismatches notDeepEquals notEntriesEqual notInstanceOf notJsonEquals notLooseEquals notStrictEquals strictEquals

Properties

endsWith

endsWith: {
    <const ArrayElement>(
        parent: readonly ArrayElement[],
        child: ArrayElement,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string,
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string | readonly string[],
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
} = ...

Checks that a parent string or array ends with a specific child. This uses reference equality when the parent is an array. Returns the value if the check passes, otherwise undefined.

Performs no type guarding.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.endsWith('ab', 'b'); // returns `'ab'`
checkWrap.endsWith('ab', 'a'); // returns `undefined`
checkWrap.endsWith(['a', 'b'], 'b'); // returns `['a', 'b']`
checkWrap.endsWith(['a', 'b'], 'a'); // returns `undefined`

Returns

The first value if the check passes, otherwise undefined.

See

checkWrap.endsWithout : the opposite check.
checkWrap.startsWith : check on the other end.

endsWithout

endsWithout: {
    <const ArrayElement>(
        parent: readonly ArrayElement[],
        child: ArrayElement,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string,
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string | readonly string[],
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
} = ...

Checks that a parent string or array does not end with a specific child. This uses reference equality when the parent is an array. Returns the value if the check passes, otherwise undefined.

Performs no type guarding.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.endsWithout('ab', 'b'); // returns `undefined`
checkWrap.endsWithout('ab', 'a'); // returns `'ab'`
checkWrap.endsWithout(['a', 'b'], 'b'); // returns `undefined`
checkWrap.endsWithout(['a', 'b'], 'a'); // returns `['a', 'b']`

Returns

The first value if the check passes, otherwise undefined.

See

checkWrap.endsWith : the opposite check.
checkWrap.startsWithout : check on the other end.

isDefined

isDefined: undefined = undefined

isLengthAtLeast

isLengthAtLeast: {
    <Element, Length extends number>(
        actual: readonly (undefined | Element)[],
        length: Length,
    ): AtLeastTuple<Element, Length> | undefined;
    <Actual extends string | AnyObject>(
        actual: Actual,
        length: number,
    ): Actual | undefined;
} = ...

Checks that an array or string has at least the given length. Returns the value if the check passes, otherwise undefined.

Type guards an array into an AtLeastTuple. Performs no type guarding on a string.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.isLengthAtLeast(['a', 'b', 'c'], 2); // returns `['a', 'b', 'c']`
checkWrap.isLengthAtLeast(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
checkWrap.isLengthAtLeast(['a', 'b'], 3); // returns `undefined`

Returns

The value if the check passes, otherwise undefined.

See

checkWrap.isLengthExactly : the more exact check.

isLengthExactly

isLengthExactly: {
    <Element, Length extends number>(
        actual: readonly (undefined | Element)[],
        length: Length,
    ): Tuple<Element, Length> | undefined;
    <Actual extends string | AnyObject>(
        actual: Actual,
        length: number,
    ): Actual | undefined;
} = ...

Checks that an array or string has exactly the given length. Returns the value if the check passes, otherwise undefined.

Type guards an array into a Tuple. Performs no type guarding on a string.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.isLengthExactly(['a', 'b', 'c'], 2); // returns `undefined`
checkWrap.isLengthExactly(['a', 'b', 'c'], 3); // returns `['a', 'b', 'c']`
checkWrap.isLengthExactly(['a', 'b'], 3); // returns `undefined`

Returns

The value if the check passes, otherwise undefined.

See

checkWrap.isLengthAtLeast : the more flexible check.

isNullish

isNullish: undefined = undefined

output

output: {
    <const FunctionToCall extends AnyFunction>(
        functionToCall: FunctionToCall,
        inputs: Parameters<NoInfer<FunctionToCall>>,
        expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>,
        failureMessage?: string,
    ): OutputReturn<
        FunctionToCall,
        Awaited<ReturnType<NoInfer<FunctionToCall>>>
        | undefined,
    >;
    <const FunctionToCall extends AnyFunction>(
        asserter: CustomOutputAsserter<NoInfer<FunctionToCall>>,
        functionToCall: FunctionToCall,
        inputs: Parameters<NoInfer<FunctionToCall>>,
        expectedOutput: Awaited<ReturnType<NoInfer<FunctionToCall>>>,
        failureMessage?: string,
    ): OutputReturn<
        FunctionToCall,
        Awaited<ReturnType<NoInfer<FunctionToCall>>>
        | undefined,
    >;
} = checkWrapOutput

Asserts that the output of the given function deeply equals expectations. A custom asserter can optionally be provided as the first argument to change the expectation checking from the default "deeply equals" to whatever you want. Returns the output if the check passes, otherwise undefined.

Performs no type guarding.

import {checkWrap} from '@augment-vir/assert';

checkWrap.output((input: number) => String(input), [5], '5'); // returns `'5'`
checkWrap.output((input: number) => String(input), [10], '5'); // returns `undefined`

checkWrap.output(assert.isLengthAtLeast, (input: number) => String(input), [5], 2); // returns `undefined`
checkWrap.output(assert.isLengthAtLeast, (input: number) => String(input), [10], 2); // returns `10`

Returns

The output if the assertion passes, otherwise undefined.

startsWith

startsWith: {
    <const ArrayElement>(
        parent: readonly ArrayElement[],
        child: ArrayElement,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string,
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string | readonly string[],
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
} = ...

Checks that a parent string or array starts with a specific child. This uses reference equality when the parent is an array. Returns the value if the check passes, otherwise undefined.

Performs no type guarding.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.startsWith('ab', 'b'); // returns `undefined`
checkWrap.startsWith('ab', 'a'); // returns `'ab'`
checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`

Returns

The first value if the check passes, otherwise undefined.

See

checkWrap.startsWithout : the opposite check.
checkWrap.endsWith : check on the other end.

startsWithout

startsWithout: {
    <const ArrayElement>(
        parent: readonly ArrayElement[],
        child: ArrayElement,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string,
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
    (
        parent: string | readonly string[],
        child: string,
        failureMessage?: string,
    ): typeof parent | undefined;
} = ...

Checks that a parent string or array starts with a specific child. This uses reference equality when the parent is an array. Returns the value if the check passes, otherwise undefined.

Performs no type guarding.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.startsWith('ab', 'b'); // returns `undefined`
checkWrap.startsWith('ab', 'a'); // returns `'ab'`
checkWrap.startsWith(['a', 'b'], 'b'); // returns `undefined`
checkWrap.startsWith(['a', 'b'], 'a'); // returns `['a', 'b']`

Returns

The first value if the check passes, otherwise undefined.

See

checkWrap.startsWithout : the opposite check.
checkWrap.endsWith : check on the other end.

throws

throws: {
    (
        this: void,
        callbackOrPromise: () => never,
        matchOptions?: PartialWithNullable<
            {
                matchConstructor: ErrorConstructor
                | new (...args: any[]) => Error;
                matchMessage: string | RegExp;
            },
        >,
        failureMessage?: string,
    ): Error | undefined;
    (
        this: void,
        callbackOrPromise: Promise<any> | () => Promise<any>,
        matchOptions?: PartialWithNullable<
            {
                matchConstructor: ErrorConstructor
                | new (...args: any[]) => Error;
                matchMessage: string | RegExp;
            },
        >,
        failureMessage?: string,
    ): Promise<Error | undefined>;
    (
        this: void,
        callback: () => any,
        matchOptions?: PartialWithNullable<
            {
                matchConstructor: ErrorConstructor
                | new (...args: any[]) => Error;
                matchMessage: string | RegExp;
            },
        >,
        failureMessage?: string,
    ): Error | undefined;
    (
        this: void,
        callback: Promise<any> | () => any,
        matchOptions?: PartialWithNullable<
            {
                matchConstructor: ErrorConstructor
                | new (...args: any[]) => Error;
                matchMessage: string | RegExp;
            },
        >,
        failureMessage?: string,
    ): MaybePromise<Error | undefined>;
} = throwsCheckWrap

If a function input is provided:

Calls that function and checks that the function throw an error, comparing the error with the given ErrorMatchOptions, if provided. Returns the error if the check passes, otherwise undefined.

If a promise is provided:

Awaits the promise and checks that the promise rejected with an error, comparing the error with the given ErrorMatchOptions, if provided. Returns the error if the check passes, otherwise undefined.

This assertion will automatically type itself as async vs async based on the input. (A promise or async function inputs results in async. Otherwise, sync.)

Performs no type guarding.

Example

import {checkWrap} from '@augment-vir/assert';

checkWrap.throws(() => {
    throw new Error();
}); // returns the thrown error
await checkWrap.throws(Promise.reject()); // returns the rejection
checkWrap.throws(() => {}); // returns `undefined`

Returns

The Error if the check passes, otherwise undefined.

Methods

deepEquals

deepEquals<Actual, Expected>(
    this: void,
    actual: Actual,
    expected: Expected,
): undefined | NarrowToExpected<Actual, Expected>
Checks that two values are deeply equal using the deep-eql package. Returns the first value if the check passes.

Note that this check may be expensive, depending on what values it is passed. Whenever possible, use simpler equality checks instead (see the see section below).

Type guards the first value.
Type Parameters
- Actual
- Expected
Parameters
- this: void
- actual: Actual
- expected: Expected
Returns undefined | NarrowToExpected<Actual, Expected>
The first value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.deepEquals('a', 'a'); // true

checkWrap.deepEquals('1', 1); // false

checkWrap.deepEquals({a: 'a'}, {a: 'a'}); // true

const objectExample = {a: 'a'};
checkWrap.deepEquals(objectExample, objectExample); // true
```
See
- checkWrap.notDeepEquals : the opposite check.
- checkWrap.entriesEqual : a less expensive (but less thorough) deep equality check.
- checkWrap.jsonEquals : a less expensive (but less thorough) deep equality check.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:877

entriesEqual

entriesEqual<Actual extends object, Expected extends object>(
    this: void,
    actual: Actual,
    expected: Expected,
): undefined | NarrowToExpected<Actual, Expected>
Checks that two objects are deeply equal by checking only their top-level values for strict (non-deep, reference, using ===) equality. If the check passes the first object is returned. If not, undefined is returned.

Type guards the first value.
Type Parameters
- Actual extends object
- Expected extends object
Parameters
- this: void
- actual: Actual
- expected: Expected
Returns undefined | NarrowToExpected<Actual, Expected>
The first input if the assertion passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.entriesEqual({a: 'a'}, {a: 'a'}); // returns `{a: 'a'}`

checkWrap.entriesEqual({a: {b: 'b'}}, {a: {b: 'b'}}); // returns `undefined`

const bExample = {b: 'b'};
checkWrap.entriesEqual({a: bExample}, {a: bExample}); // returns `{a: {b: 'b'}}`
```
See
- checkWrap.notEntriesEqual : the opposite check.
- checkWrap.jsonEquals : another deep equality check.
- checkWrap.deepEquals : the most thorough (but also slow) deep equality check.
- Defined in packages/assert/src/assertions/equality/entry-equality.ts:382

hasKey

hasKey<const Parent, const Key extends PropertyKey>(
    this: void,
    parent: Parent,
    key: Key,
): undefined | CombineTypeWithKey<Key, Parent>
Checks that a parent value has the key. Returns the parent value if the check passes, otherwise undefined.

Type guards the parent value.
Type Parameters
- const Parent
- const Key extends PropertyKey
Parameters
- this: void
- parent: Parent
- key: Key
Returns undefined | CombineTypeWithKey<Key, Parent>
The parent value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.hasKey({a: 0, b: 1}, 'a'); // returns `{a: 0, b: 1}`
checkWrap.hasKey({a: 0, b: 1}, 'c'); // returns `undefined`
```
See
- checkWrap.lacksKey : the opposite check.
- checkWrap.hasKeys : the multi-key check.
- Defined in packages/assert/src/assertions/keys.ts:688

hasKeys

hasKeys<const Keys extends PropertyKey, const Parent>(
    this: void,
    parent: Parent,
    keys: readonly Keys[],
): undefined | CombineTypeWithKey<Keys, Parent>
Checks that a parent value has all the keys. Returns the parent value if the check passes, otherwise undefined.

Type guards the parent value.
Type Parameters
- const Keys extends PropertyKey
- const Parent
Parameters
- this: void
- parent: Parent
- keys: readonly Keys[]
Returns undefined | CombineTypeWithKey<Keys, Parent>
The parent value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.hasKeys({a: 0, b: 1}, ['a', 'b']); // returns `{a: 0, b: 1}`
checkWrap.hasKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
```
See
- checkWrap.lacksKeys : the opposite check.
- checkWrap.hasKey : the single-key check.
- Defined in packages/assert/src/assertions/keys.ts:750

hasValue

hasValue<Parent extends string | object>(
    this: void,
    parent: Parent,
    value: unknown,
): undefined | Parent
Checks that an object/array parent includes a child value through reference equality.

Performs no type guarding.
Type Parameters
- Parent extends string | object
Parameters
- this: void
- parent: Parent
- value: unknown
Returns undefined | Parent
Example
```
import {checkWrap} from '@augment-vir/assert';

const child = {a: 'a'};

checkWrap.hasValue({child}, child); // returns `{child}`
checkWrap.hasValue({child: {a: 'a'}}, child); // returns `undefined`
checkWrap.hasValue([child], child); // returns `[child]`
```
See
- checkWrap.lacksValue : the opposite check.
- checkWrap.hasValues : the multi-value check.
- Defined in packages/assert/src/assertions/values.ts:1082

hasValues

hasValues<Parent extends string | object>(
    this: void,
    parent: Parent,
    values: unknown[],
): undefined | Parent
Checks that an object/array parent includes all child values through reference equality.

Performs no type guarding.
Type Parameters
- Parent extends string | object
Parameters
- this: void
- parent: Parent
- values: unknown[]
Returns undefined | Parent
Example
```
import {checkWrap} from '@augment-vir/assert';

const child = {a: 'a'};
const child2 = {b: 'b'};

checkWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`
checkWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
checkWrap.hasValues([child], [child, child2]); // returns `[child]`
```
See
- checkWrap.lacksValues : the opposite check.
- checkWrap.hasValue : the single-value check.
- Defined in packages/assert/src/assertions/values.ts:1148

instanceOf

instanceOf<const Instance>(
    this: void,
    instance: unknown,
    constructor: Constructor<Instance>,
): undefined | Instance
Checks that a value is an instance of the given class constructor. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- const Instance
Parameters
- this: void
- instance: unknown
- constructor: Constructor<Instance>
Returns undefined | Instance
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.instanceOf(/abc/, RegExp); // returns `/abc/`
checkWrap.instanceOf('abc', RegExp); // returns `undefined`
```
See
- checkWrap.notInstanceOf : the opposite check.
- Defined in packages/assert/src/assertions/instance.ts:219

isAbove

isAbove<Actual extends number>(
    this: void,
    actual: Actual,
    expected: number,
): undefined | Actual
Checks that a number is above the expectation (actual > expected). Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- expected: number
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isAbove(10, 5); // returns `10`
checkWrap.isAbove(5, 5); // returns `undefined`
checkWrap.isAbove(5, 10); // returns `undefined`
```
See
- checkWrap.isBelow : the opposite check.
- checkWrap.isAtLeast : the more lenient check.
- Defined in packages/assert/src/assertions/numeric.ts:1264

isApproximately

isApproximately<Actual extends number>(
    this: void,
    actual: Actual,
    expected: number,
    delta: number,
): undefined | Actual
Checks that a number is within ±delta of the expectation. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- expected: number
- delta: number
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isApproximately(10, 8, 4); // returns `10`
checkWrap.isApproximately(10, 12, 4); // returns `10`
checkWrap.isApproximately(10, 8, 1); // returns `undefined`
checkWrap.isApproximately(10, 12, 1); // returns `undefined`
```
See
- checkWrap.isNotApproximately : the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1478

isArray

isArray<Actual>(this: void, actual: Actual): undefined | ArrayNarrow<Actual>
Checks that a value is an array. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | ArrayNarrow<Actual>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isArray([]); // returns `[]`
checkWrap.isArray({length: 4}); // returns `undefined`
```
See
- checkWrap.isNotArray : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1640

isAtLeast

isAtLeast<Actual extends number>(
    this: void,
    actual: Actual,
    expected: number,
): undefined | Actual
Checks that a number is at least the expectation (actual >= expected). Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- expected: number
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isAtLeast(10, 5); // returns `10`
checkWrap.isAtLeast(5, 5); // returns `5`
checkWrap.isAtLeast(5, 10); // returns `undefined`
```
See
- checkWrap.isAtMost : the opposite check.
- checkWrap.isAbove : the more restrictive check.
- Defined in packages/assert/src/assertions/numeric.ts:1296

isAtMost

isAtMost<Actual extends number>(
    this: void,
    actual: Actual,
    expected: number,
): undefined | Actual
Checks that a number is at most the expectation (actual <= expected). Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- expected: number
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isAtMost(10, 5); // returns `undefined`
checkWrap.isAtMost(5, 5); // returns `5`
checkWrap.isAtMost(5, 10); // returns `5`
```
See
- checkWrap.isAtLeast : the opposite check.
- checkWrap.isBelow : the more restrictive check.
- Defined in packages/assert/src/assertions/numeric.ts:1360

isBelow

isBelow<Actual extends number>(
    this: void,
    actual: Actual,
    expected: number,
): undefined | Actual
Checks that a number is below the expectation (actual < expected). Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- expected: number
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isBelow(10, 5); // returns `undefined`
checkWrap.isBelow(5, 5); // returns `undefined`
checkWrap.isBelow(5, 10); // returns `5`
```
See
- checkWrap.isAbove : the opposite check.
- checkWrap.isAtMost : the more lenient check.
- Defined in packages/assert/src/assertions/numeric.ts:1328

isBigInt

isBigInt<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, bigint>
Checks that a value is a BigInt. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, bigint>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isBigInt(123n); // returns `123n`
checkWrap.isBigInt(123); // returns `undefined`
```
See
- checkWrap.isNotBigInt : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1666

isBoolean

isBoolean<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, boolean>
Checks that a value is a boolean. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, boolean>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isBoolean(true); // returns `true`
checkWrap.isBoolean('true'); // returns `undefined`
```
See
- checkWrap.isNotBoolean : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1692

isEmpty

isEmpty<Actual extends CanBeEmpty>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, Empty>
Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.

Type guards the value.
Type Parameters
- Actual extends CanBeEmpty
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, Empty>
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isEmpty({}); // returns `{}`
checkWrap.isEmpty(''); // returns `''`
checkWrap.isEmpty([]); // returns `[]`

checkWrap.isEmpty('a'); // returns `undefined`
checkWrap.isEmpty({a: 'a'}); // returns `undefined`
```
See
- checkWrap.isNotEmpty : the opposite check.
- Defined in packages/assert/src/assertions/values.ts:1284

isEnumValue

isEnumValue<const Actual, const Expected extends EnumBaseType>(
    this: void,
    child: Actual,
    checkEnum: Expected,
): undefined | NarrowToExpected<Actual, Expected[keyof Expected]>
Checks that a child value is an enum member. Returns the child value if the check passes, otherwise undefined.

Type guards the child value.
Type Parameters
- const Actual
- const Expected extends EnumBaseType
Parameters
- this: void
- child: Actual
- checkEnum: Expected
Returns undefined | NarrowToExpected<Actual, Expected[keyof Expected]>
The child value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

enum MyEnum {
    A = 'a',
    B = 'b',
}

checkWrap.isEnumValue('a', MyEnum); // returns `'a'`
checkWrap.isEnumValue('A', MyEnum); // returns `undefined`
```
See
- checkWrap.isNotEnumValue : the opposite check.
- Defined in packages/assert/src/assertions/enum.ts:269

isError

isError<Actual>(
    this: void,
    actual: Actual,
    matchOptions?: PartialWithNullable<
        {
            matchConstructor: ErrorConstructor
            | new (...args: any[]) => Error;
            matchMessage: string | RegExp;
        },
    >,
): undefined
| NarrowToExpected<Actual, Error>
Checks that a value is an instance of the built-in Error class and compares it to the given ErrorMatchOptions, if provided. Returns the error if the check passes, otherwise undefined.

Type guards the input.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalmatchOptions: PartialWithNullable<
      {
          matchConstructor: ErrorConstructor
          | new (...args: any[]) => Error;
          matchMessage: string | RegExp;
      },
  >
Returns undefined | NarrowToExpected<Actual, Error>
The Error if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isError(new Error()); // returns the Error
checkWrap.isError(new Error(), {matchMessage: 'hi'}); // returns `undefined`
checkWrap.isError({message: 'not an error'}); // returns `undefined`
```
- Defined in packages/assert/src/assertions/throws.ts:699

isFalse

isFalse(this: void, input: unknown): undefined | false
Checks that a value is exactly false. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Parameters
- this: void
- input: unknown
Returns undefined | false
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isFalse(true); // returns `false`
checkWrap.isFalse(false); // returns `true`
checkWrap.isFalse(1); // returns `false`
checkWrap.isFalse(0); // returns `false`
```
See
- checkWrap.isTrue : the opposite check.
- checkWrap.isFalsy : a less exact check.
- Defined in packages/assert/src/assertions/boolean.ts:415

isFalsy

isFalsy<T>(this: void, input: T): undefined | NarrowToExpected<T, FalsyValue>
Checks that a value is falsy. Returns the value if the check passes, otherwise undefined.

Type guards the value when possible.
Type Parameters
- T
Parameters
- this: void
- input: T
Returns undefined | NarrowToExpected<T, FalsyValue>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isFalsy(true); // returns `false`
checkWrap.isFalsy(false); // returns `true`
checkWrap.isFalsy(1); // returns `false`
checkWrap.isFalsy(0); // returns `true`
```
See
- checkWrap.isTruthy : the opposite check.
- checkWrap.isFalse : a more exact check.
- Defined in packages/assert/src/assertions/boolean.ts:444

isFinite

isFinite<Actual extends number>(this: void, actual: Actual): undefined | Actual
Checks that a number is finite: meaning, not NaN and not Infinity or -Infinity. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isFinite(10); // returns `10`
checkWrap.isFinite(parseInt('invalid')); // returns `undefined`
checkWrap.isFinite(Infinity); // returns `undefined`
checkWrap.isFinite(-Infinity); // returns `undefined`
```
See
- checkWrap.isNaN : an opposite check.
- checkWrap.isInfinite : an opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1421

isFunction

isFunction<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, AnyFunction>
Checks that a value is a function. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, AnyFunction>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isFunction(() => {}); // returns `() => {}`
checkWrap.isFunction({}); // returns `undefined`
```
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1718

isHttpStatus

isHttpStatus<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToExpected<Actual, HttpStatus>
Checks that a value is an HttpStatus. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToExpected<Actual, HttpStatus>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isHttpStatus(400); // returns `400`
checkWrap.isHttpStatus(500); // returns `500`
checkWrap.isHttpStatus(99); // returns `undefined`
```
See
- checkWrap.isHttpStatusCategory : the category check.
- HttpStatus : all included statuses.
- HttpStatusCategory : all status categories.
- Defined in packages/assert/src/assertions/http.ts:250

isHttpStatusCategory

isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(
    this: void,
    actual: Actual,
    category: Category,
): undefined | NarrowToExpected<Actual, HttpStatusByCategory<Category>>
Checks that a value is an HttpStatus within a specific HttpStatusCategory. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- const Actual
- const Category extends HttpStatusCategory
Parameters
- this: void
- actual: Actual
- category: Category
Returns undefined | NarrowToExpected<Actual, HttpStatusByCategory<Category>>
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isHttpStatusCategory(400, HttpStatusCategory.ClientError); // returns `400`
checkWrap.isHttpStatusCategory(500, HttpStatusCategory.Success); // returns `undefined`
checkWrap.isHttpStatusCategory(99, HttpStatusCategory.Information); // returns `undefined`
```
See
- checkWrap.isHttpStatus : the status check.
- HttpStatus : all included statuses.
- HttpStatusCategory : all status categories.
- Defined in packages/assert/src/assertions/http.ts:281

isIn

isIn<Parent extends string | object, Child>(
    this: void,
    child: Child,
    parent: Parent,
): undefined | Extract<Child, Values<Parent>>
Checks that child value is contained within a parent object, array, or string through reference equality.

Type guards the child when possible.
Type Parameters
- Parent extends string | object
- Child
Parameters
- this: void
- child: Child
- parent: Parent
Returns undefined | Extract<Child, Values<Parent>>
Example
```
import {checkWrap} from '@augment-vir/assert';

const child = {a: 'a'};

checkWrap.isIn(child, {child}); // returns `child`
checkWrap.isIn('a', 'ab'); // returns `'a'`
checkWrap.isIn(child, [child]); // returns `child`

checkWrap.isIn(child, {child: {a: 'a'}}); // returns `undefined`
checkWrap.isIn('a', 'bc'); // returns `undefined`
```
See
- checkWrap.isNotIn : the opposite check.
- Defined in packages/assert/src/assertions/values.ts:1217

isInBounds

isInBounds<Actual extends number>(
    this: void,
    actual: Actual,
    __namedParameters: MinMax,
): undefined | Actual
Checks that a number is inside the provided min and max bounds, inclusive. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- __namedParameters: MinMax
Returns undefined | Actual
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isInBounds(5, {min: 1, max: 10}); // returns `5`
checkWrap.isInBounds(10, {min: 1, max: 10}); // returns `10`
checkWrap.isInBounds(11, {min: 1, max: 10}); // returns `undefined`
checkWrap.isInBounds(0, {min: 1, max: 10}); // returns `undefined`
```
See
- checkWrap.isOutBounds : the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1144

isInfinite

isInfinite<Actual extends number>(
this: void,
actual: Actual,
): undefined | Actual
Checks that a number is either Infinity or -Infinity. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isInfinite(10); // returns `undefined`
checkWrap.isInfinite(parseInt('invalid')); // returns `undefined`
checkWrap.isInfinite(Infinity); // returns `Infinity`
checkWrap.isInfinite(-Infinity); // returns `-Infinity`
```
See
- checkWrap.isNaN : an opposite check.
- checkWrap.isInfinite : an opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1450

isInteger

isInteger<Actual extends number>(this: void, actual: Actual): undefined | Actual
Checks that a number is an integer. Returns the number if the check passes, otherwise undefined. This has the same limitations as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
Returns undefined | Actual
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isInteger(5); // returns `5`
checkWrap.isInteger(5.0000000000000001); // returns `5`
checkWrap.isInteger(5.1); // returns `undefined`
checkWrap.isInteger(NaN); // returns `undefined`
```
See
- checkWrap.isNotInteger : the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1208

isKeyOf

isKeyOf<const Key extends PropertyKey, const Parent>(
    this: void,
    key: Key,
    parent: Parent,
): undefined | NarrowToExpected<Key, keyof Parent>
Checks that a key is contained within a parent value. Returns the key if the check passes, otherwise undefined.

Type guards the key.
Type Parameters
- const Key extends PropertyKey
- const Parent
Parameters
- this: void
- key: Key
- parent: Parent
Returns undefined | NarrowToExpected<Key, keyof Parent>
The key if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isKeyof('a', {a: 0, b: 1}); // returns `'a'`
checkWrap.isKeyof('c', {a: 0, b: 1}); // returns `undefined`
```
See
- checkWrap.isNotKeyOf : the opposite check.
- Defined in packages/assert/src/assertions/keys.ts:627

isNaN

isNaN<Actual extends number>(this: void, actual: Actual): undefined | Actual
Checks that a number is NaN. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNaN(10); // returns `undefined`
checkWrap.isNaN(parseInt('invalid')); // returns `NaN`
checkWrap.isNaN(Infinity); // returns `undefined`
```
See
- checkWrap.isNumber : can be used as the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1392

isNotApproximately

isNotApproximately<Actual extends number>(
    this: void,
    actual: Actual,
    expected: number,
    delta: number,
): undefined | Actual
Checks that a number is outside ±delta of the expectation. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- expected: number
- delta: number
Returns undefined | Actual
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotApproximately(10, 8, 4); // returns `undefined`
checkWrap.isNotApproximately(10, 12, 4); // returns `undefined`
checkWrap.isNotApproximately(10, 8, 1); // returns `10`
checkWrap.isNotApproximately(10, 12, 1); // returns `10`
```
See
- checkWrap.isApproximately : the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1511

isNotArray

isNotArray<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, readonly unknown[]>
Checks that a value is not an array. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, readonly unknown[]>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotArray([]); // returns `undefined`
checkWrap.isNotArray({length: 4}); // returns `{length: 4}`
```
See
- checkWrap.isArray : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1881

isNotBigInt

isNotBigInt<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, bigint>
Checks that a value is not a BigInt. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, bigint>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotBigInt(123n); // returns `undefined`
checkWrap.isNotBigInt(123); // returns `123`
```
See
- checkWrap.isBigInt : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1910

isNotBoolean

isNotBoolean<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, boolean>
Checks that a value is not a boolean. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, boolean>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotBoolean(true); // returns `undefined`
checkWrap.isNotBoolean('true'); // returns `'true'`
```
See
- checkWrap.isBoolean : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1936

isNotEmpty

isNotEmpty<Actual extends CanBeEmpty>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, Empty>
Checks that a value is not empty. Supports strings, Maps, Sets, objects, and arrays.

Type guards the value.
Type Parameters
- Actual extends CanBeEmpty
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, Empty>
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotEmpty({}); // returns `undefined`
checkWrap.isNotEmpty(''); // returns `undefined`
checkWrap.isNotEmpty([]); // returns `undefined`

checkWrap.isNotEmpty('a'); // returns `'a'`
checkWrap.isNotEmpty({a: 'a'}); // returns `{a: 'a'}`
```
See
- checkWrap.isEmpty : the opposite check.
- Defined in packages/assert/src/assertions/values.ts:1331

isNotEnumValue

isNotEnumValue<const Actual, const Expected extends EnumBaseType>(
    this: void,
    child: Actual,
    checkEnum: Expected,
):
    | undefined
    | Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>
Checks that a child value is not an enum member. Returns the child value if the check passes, otherwise undefined.

Type guards the child value.
Type Parameters
- const Actual
- const Expected extends EnumBaseType
Parameters
- this: void
- child: Actual
- checkEnum: Expected
Returns
| undefined
| Exclude<Actual, Expected[keyof Expected] | `${Expected[keyof Expected]}`>
The child value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

enum MyEnum {
    A = 'a',
    B = 'b',
}

checkWrap.isNotEnumValue('a', MyEnum); // returns `undefined`
checkWrap.isNotEnumValue('A', MyEnum); // returns `'A'`
```
See
- checkWrap.isEnumValue : the opposite check.
- Defined in packages/assert/src/assertions/enum.ts:305

isNotFunction

isNotFunction<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, AnyFunction>
Checks that a value is not a function. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, AnyFunction>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotFunction(() => {}); // returns `undefined`
checkWrap.isNotFunction({}); // returns `{}`
```
See
- checkWrap.isFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1962

isNotIn

isNotIn<Parent extends string | object, Child>(
    this: void,
    child: Child,
    parent: Parent,
): undefined | Exclude<Child, Values<Parent>>
Checks that child value is not contained within a parent object, array, or string through reference equality.

Type guards the child when possible.
Type Parameters
- Parent extends string | object
- Child
Parameters
- this: void
- child: Child
- parent: Parent
Returns undefined | Exclude<Child, Values<Parent>>
Example
```
import {checkWrap} from '@augment-vir/assert';

const child = {a: 'a'};

checkWrap.isNotIn(child, {child}); // returns `undefined`
checkWrap.isNotIn('a', 'ab'); // returns `undefined`
checkWrap.isNotIn(child, [child]); // returns `undefined`

checkWrap.isNotIn(child, {child: {a: 'a'}}); // returns `child`
checkWrap.isNotIn('a', 'bc'); // returns `'a'`
```
See
- checkWrap.isIn : the opposite check.
- Defined in packages/assert/src/assertions/values.ts:1252

isNotInteger

isNotInteger<Actual extends number>(
this: void,
actual: Actual,
): undefined | Actual
Checks that a number is not an integer. Returns the number if the check passes, otherwise undefined. This has the same limitations, as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
Returns undefined | Actual
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotInteger(5); // returns `undefined`
checkWrap.isNotInteger(5.0000000000000001); // returns `undefined`
checkWrap.isNotInteger(5.1); // returns `5.1`
checkWrap.isNotInteger(NaN); // returns `NaN`
```
See
- checkWrap.isInteger : the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1236

isNotKeyOf

isNotKeyOf<const Key extends PropertyKey, const Parent>(
    this: void,
    key: Key,
    parent: Parent,
): undefined | Exclude<Key, RequiredKeysOf<Parent>>
Checks that a key is not contained within a parent value. Returns the key if the check passes, otherwise undefined.

Type guards the key.
Type Parameters
- const Key extends PropertyKey
- const Parent
Parameters
- this: void
- key: Key
- parent: Parent
Returns undefined | Exclude<Key, RequiredKeysOf<Parent>>
The key if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotKeyOf('a', {a: 0, b: 1}); // returns `undefined`
checkWrap.isNotKeyOf('c', {a: 0, b: 1}); // returns `'c'`
```
See
- checkWrap.isKeyOf : the opposite check.
- Defined in packages/assert/src/assertions/keys.ts:657

isNotNull

isNotNull<Actual>(this: void, actual: Actual): undefined | Exclude<Actual, null>
Checks that a value is not exactly null. Returns the value if the check passes, otherwise undefined`.

Type guards the value.

@example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotNull(null); // returns `undefined`
checkWrap.isNotNull(undefined); // returns `undefined`
```
@returns The value if the check passes. Otherwise, undefined.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, null>
See
- checkWrap.isFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1991

isNotNumber

isNotNumber<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, number>
Checks that a value is not a number. This includes NaN. Returns the value if the check passes, otherwise undefined`.

Type guards the value.

@example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotNumber(123); // returns `undefined`
checkWrap.isNotNumber(123n); // returns `123n`
```
@returns The value if the check passes. Otherwise, undefined.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, number>
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:2017

isNotObject

isNotObject<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, UnknownObject>
Checks that a value is not an object. This includes arrays. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, UnknownObject>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotObject({}); // returns `undefined`
checkWrap.isNotObject([]); // returns `[]`
```
See
- checkWrap.isFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:2043

isNotPrimitive

isNotPrimitive<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, Primitive>
Checks that a value is a valid PropertyKey. PropertyKey is a built-in TypeScript type which refers to all possible key types for a JavaScript object. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, Primitive>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotPrimitive('key'); // returns `undefined`
checkWrap.isNotPrimitive(true); // returns `undefined`
checkWrap.isNotPrimitive({}); // returns `{}`
```
See
- checkWrap.isPrimitive : the opposite check.
- Defined in packages/assert/src/assertions/primitive.ts:444

isNotPromise

isNotPromise<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, Promise<any>>

Checks that a value is a not Promise instance. Returns the value if the check passes, otherwise undefined.

Type guards the value.

Type Parameters

Actual

Parameters

this: void
actual: Actual

Returns undefined | Exclude<Actual, Promise<any>>

Example

import {checkWrap} from '@augment-vir/assert';

class CustomThenable {
    constructor(public value: any) {}

    then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
        return new CustomThenable(
            onFulfilled ? onFulfilled(this.value) : this.value,
        );
    }
}

checkWrap.isNotPromise(Promise.resolve(5)); // returns `false`
checkWrap.isNotPromise(new CustomThenable(5)); // returns `true`
checkWrap.isNotPromise(5); // returns `true`

See

checkWrap.isPromise : the opposite check.
checkWrap.isNotPromiseLike : the more lenient check.

isNotPromiseLike

isNotPromiseLike<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, PromiseLike<any>>
Checks that a value is not a PromiseLike. Returns the value if the check passes, otherwise undefined.

PromiseLike is TypeScript built-in type that has a .then method and thus behaves like a promise. This is also referred to as a "thenable". This enables the use of third-party promise implementations that aren't instances of the built-in Promise class.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, PromiseLike<any>>
Example
```
import {checkWrap} from '@augment-vir/assert';

class CustomThenable {
    constructor(public value: any) {}

    then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
        return new CustomThenable(
            onFulfilled ? onFulfilled(this.value) : this.value,
        );
    }
}

checkWrap.isNotPromiseLike(Promise.resolve(5)); // returns `false`
checkWrap.isNotPromiseLike(new CustomThenable(5)); // returns `false`
checkWrap.isNotPromiseLike(5); // returns `true`
```
See
- checkWrap.isPromiseLike : the opposite check.
- checkWrap.isNotPromise : the more precise check.
- Defined in packages/assert/src/assertions/promise.ts:627

isNotPropertyKey

isNotPropertyKey<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, PropertyKey>
Checks that a value is not a valid PropertyKey. PropertyKey is a built-in TypeScript type which refers to all possible key types for a JavaScript object. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, PropertyKey>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotPropertyKey('key'); // returns `undefined`
checkWrap.isNotPropertyKey(true); // returns `true`
checkWrap.isNotPropertyKey({}); // returns `{}`
```
See
- checkWrap.isPropertyKey : the opposite check.
- Defined in packages/assert/src/assertions/primitive.ts:476

isNotString

isNotString<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, string>
Checks that a value is not a string. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, string>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotString(''); // returns `undefined`
checkWrap.isNotString(5); // returns `5`
```
See
- checkWrap.isFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:2072

isNotSymbol

isNotSymbol<Actual>(
this: void,
actual: Actual,
): undefined | Exclude<Actual, symbol>
Checks that a value is not a symbol. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Exclude<Actual, symbol>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNotSymbol(Symbol('my-symbol')); // returns `undefined`
checkWrap.checkWrap('my-symbol'); // returns `'my-symbol'`
```
See
- checkWrap.isFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:2098

isNotUuid

isNotUuid<Actual>(
    this: void,
    actual: Actual,
):
    | undefined
    | Exclude<Actual, `${string}-${string}-${string}-${string}-${string}`>

Checks that a value is not a valid UUID. The nil or max UUIDs are included as not valid. Returns the value if the check passes, otherwise undefined.

Type guards the value.

Type Parameters

Actual

Parameters

this: void
actual: Actual

Returns undefined | Exclude<Actual, `${string}-${string}-${string}-${string}-${string}`>

The value if the check passes, otherwise undefined.

Example

import {checkWrap} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';

checkWrap.isNotUuid(createUuidV4()); // returns `undefined`
checkWrap.isNotUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // returns `undefined`
checkWrap.isNotUuid('00000000-0000-0000-0000-000000000000'); // returns `'00000000-0000-0000-0000-000000000000'`
checkWrap.isNotUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // returns `'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'`
checkWrap.isNotUuid('not-a-uuid'); // returns `'not-a-uuid'`

See

checkWrap.isUuid : the opposite check.

isNull

isNull<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, null>
Checks that a value is exactly null. Returns the value if the check passes, otherwise undefined`.

Type guards the value.

@example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNull(null); // returns `null`
checkWrap.isNull(undefined); // returns `undefined`
```
@returns The value if the check passes. Otherwise, undefined.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, null>
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1747

isNumber

isNumber<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, number>
Checks that a value is a number. This excludes NaN. Returns the value if the check passes, otherwise undefined`.

Type guards the value.

@example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isNumber(123); // returns `123`
checkWrap.isNumber(123n); // returns `undefined`
```
@returns The value if the check passes. Otherwise, undefined.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, number>
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1773

isObject

isObject<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, UnknownObject>
Checks that a value is an object. This excludes arrays. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, UnknownObject>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isObject({}); // returns `{}`
checkWrap.isObject([]); // returns `undefined`
```
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1799

isOutBounds

isOutBounds<Actual extends number>(
    this: void,
    actual: Actual,
    __namedParameters: MinMax,
): undefined | Actual
Checks that a number is outside the provided min and max bounds, exclusive. Returns the number if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual extends number
Parameters
- this: void
- actual: Actual
- __namedParameters: MinMax
Returns undefined | Actual
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isOutBounds(5, {min: 1, max: 10}); // returns `undefined`
checkWrap.isOutBounds(10, {min: 1, max: 10}); // returns `undefined`
checkWrap.isOutBounds(11, {min: 1, max: 10}); // returns `11`
checkWrap.isOutBounds(0, {min: 1, max: 10}); // returns `0`
```
See
- checkWrap.isInBounds : the opposite check.
- Defined in packages/assert/src/assertions/numeric.ts:1175

isPrimitive

isPrimitive<Actual>(
this: void,
actual: Actual,
): undefined | Extract<Actual, Primitive>
Checks that a value is a JavaScript primitive. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Extract<Actual, Primitive>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isPrimitive('key'); // returns `'key'`
checkWrap.isPrimitive(true); // returns `true`
checkWrap.isPrimitive({}); // returns `undefined`
```
See
- checkWrap.isNotPrimitive : the opposite check.
- Defined in packages/assert/src/assertions/primitive.ts:511

isPromise

isPromise<Actual>(
this: void,
actual: Actual,
): undefined | Extract<Actual, Promise<any>>

Checks that a value is a Promise instance. Returns the value if the check passes, otherwise undefined.

Type guards the value.

Type Parameters

Actual

Parameters

this: void
actual: Actual

Returns undefined | Extract<Actual, Promise<any>>

Example

import {checkWrap} from '@augment-vir/assert';

class CustomThenable {
    constructor(public value: any) {}

    then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
        return new CustomThenable(
            onFulfilled ? onFulfilled(this.value) : this.value,
        );
    }
}

checkWrap.isPromise(Promise.resolve(5)); // returns `true`
checkWrap.isPromise(new CustomThenable(5)); // returns `false`
checkWrap.isPromise(5); // returns `false`

See

checkWrap.isNotPromise : the opposite check.
checkWrap.isPromiseLike : the more lenient check.

isPromiseLike

isPromiseLike<Actual>(
this: void,
actual: Actual,
): undefined | Extract<Actual, PromiseLike<any>>
Checks that a value is a PromiseLike. Returns the value if the check passes, otherwise undefined.

PromiseLike is TypeScript built-in type that has a .then method and thus behaves like a promise. This is also referred to as a "thenable". This enables the use of third-party promise implementations that aren't instances of the built-in Promise class.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | Extract<Actual, PromiseLike<any>>
Example
```
import {checkWrap} from '@augment-vir/assert';

class CustomThenable {
    constructor(public value: any) {}

    then(onFulfilled?: AnyFunction, onRejected?: AnyFunction) {
        return new CustomThenable(
            onFulfilled ? onFulfilled(this.value) : this.value,
        );
    }
}

checkWrap.isPromiseLike(Promise.resolve(5)); // returns `true`
checkWrap.isPromiseLike(new CustomThenable(5)); // returns `true`
checkWrap.isPromiseLike(5); // returns `false`
```
See
- checkWrap.isNotPromiseLike : the opposite check.
- checkWrap.isPromise : the more precise check.
- Defined in packages/assert/src/assertions/promise.ts:577

isPropertyKey

isPropertyKey<Actual>(
    this: void,
    actual: Actual,
):
    | undefined
    | Extract<string, Actual>
    | Extract<number, Actual>
    | Extract<symbol, Actual>
Checks that a value is not a JavaScript primitive. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns
    | undefined
    | Extract<string, Actual>
    | Extract<number, Actual>
    | Extract<symbol, Actual>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isPrimitive('key'); // returns `undefined`
checkWrap.isPrimitive(true); // returns `undefined`
checkWrap.isPrimitive({}); // returns `{}`
```
See
- checkWrap.isPrimitive : the opposite check.
- Defined in packages/assert/src/assertions/primitive.ts:543

isString

isString<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, string>
Checks that a value is a string. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, string>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isString(''); // returns `''`
checkWrap.isString(5); // returns `undefined`
```
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1828

isSymbol

isSymbol<Actual>(
this: void,
actual: Actual,
): undefined | NarrowToActual<Actual, symbol>
Checks that a value is a symbol. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
Returns undefined | NarrowToActual<Actual, symbol>
The value if the check passes. Otherwise, undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isSymbol(Symbol('my-symbol')); // returns the created symbol
checkWrap.isSymbol('my-symbol'); // returns `undefined`
```
See
- checkWrap.isNotFunction : the opposite check.
- Defined in packages/assert/src/assertions/runtime-type.ts:1854

isTrue

isTrue(this: void, input: unknown): undefined | true
Checks that a value is exactly true. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Parameters
- this: void
- input: unknown
Returns undefined | true
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isTrue(true); // returns `true`
checkWrap.isTrue(false); // returns `false`
checkWrap.isTrue(1); // returns `false`
checkWrap.isTrue(0); // returns `false`
```
See
- checkWrap.isFalse : the opposite check.
- checkWrap.isTruthy : a less exact check.
- Defined in packages/assert/src/assertions/boolean.ts:473

isTruthy

isTruthy<T>(this: void, input: T): undefined | Exclude<T, FalsyValue>
Checks that a value is truthy. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- T
Parameters
- this: void
- input: T
Returns undefined | Exclude<T, FalsyValue>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.isTruthy(true); // passes
checkWrap.isTruthy(false); // fails
checkWrap.isTruthy(1); // passes
checkWrap.isTruthy(0); // fails
```
See
- checkWrap.isFalsy : the opposite check.
- checkWrap.isTrue : a more exact check.
- Defined in packages/assert/src/assertions/boolean.ts:502

isUuid

isUuid<Actual>(
    this: void,
    actual: Actual,
):
    | undefined
    | NarrowToExpected<
        Actual,
        `${string}-${string}-${string}-${string}-${string}`,
    >

Checks that a value is a valid UUID. Does not accept the nil or max UUIDs. Returns the value if the check passes, otherwise undefined.

Type guards the value.

Type Parameters

Actual

Parameters

this: void
actual: Actual

Returns
    | undefined
    | NarrowToExpected<
        Actual,
        `${string}-${string}-${string}-${string}-${string}`,
    >

The value if the check passes, otherwise undefined.

Example

import {checkWrap} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';

checkWrap.isUuid(createUuidV4()); // returns the generated UUID
checkWrap.isUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // returns `'29e0f18e-6115-4982-8342-0afcadf5d611'`
checkWrap.isUuid('00000000-0000-0000-0000-000000000000'); // returns `undefined`
checkWrap.isUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // returns `undefined`
checkWrap.isUuid('not-a-uuid'); // returns `undefined`

See

checkWrap.isNotUuid : the opposite check.

jsonEquals

jsonEquals<Actual, Expected>(
    this: void,
    actual: Actual,
    expected: Expected,
): undefined | NarrowToExpected<Actual, Expected>
Checks that two values are deeply equal when stringified into JSON. This will fail or may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Returns the first value if the check passes.

Type guards the first value.
Type Parameters
- Actual
- Expected
Parameters
- this: void
- actual: Actual
- expected: Expected
Returns undefined | NarrowToExpected<Actual, Expected>
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.jsonEquals({a: 'a'}, {a: 'a'}); // returns `{a: 'a'}`

checkWrap.jsonEquals({a: {b: 'b'}}, {a: {b: 'c'}}); // returns `undefined`
```
See
- checkWrap.notJsonEquals : the opposite check.
- checkWrap.entriesEqual : another deep equality check.
- checkWrap.deepEquals : the most thorough (but also slow) deep equality check.
- Defined in packages/assert/src/assertions/equality/json-equality.ts:320

lacksKey

lacksKey<const Parent, const Key extends PropertyKey>(
    this: void,
    parent: Parent,
    key: Key,
): undefined | Exclude<Parent, Record<Key, any>>
Checks that a parent value does not have the key. Returns the parent value if the check passes, otherwise undefined.

Type guards the parent value.
Type Parameters
- const Parent
- const Key extends PropertyKey
Parameters
- this: void
- parent: Parent
- key: Key
Returns undefined | Exclude<Parent, Record<Key, any>>
The parent value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.lacksKey({a: 0, b: 1}, 'a'); // returns `undefined`
checkWrap.lacksKey({a: 0, b: 1}, 'c'); // returns `{a: 0, b: 1}`
```
See
- checkWrap.hasKey : the opposite check.
- checkWrap.lacksKeys : the multi-key check.
- Defined in packages/assert/src/assertions/keys.ts:719

lacksKeys

lacksKeys<const Parent, const Key extends PropertyKey>(
    this: void,
    parent: Parent,
    keys: readonly Key[],
): undefined | Exclude<Parent, Partial<Record<Key, any>>>
Checks that a parent value none of the keys. Returns the parent value if the check passes, otherwise undefined.

Type guards the parent value.
Type Parameters
- const Parent
- const Key extends PropertyKey
Parameters
- this: void
- parent: Parent
- keys: readonly Key[]
Returns undefined | Exclude<Parent, Partial<Record<Key, any>>>
The parent value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.lacksKeys({a: 0, b: 1}, ['b', 'c']); // returns `undefined`
checkWrap.lacksKeys({a: 0, b: 1}, ['c', 'd']); // returns `{a: 0, b: 1}`
```
See
- checkWrap.hasKeys : the opposite check.
- checkWrap.lacksKey : the single-key check.
- Defined in packages/assert/src/assertions/keys.ts:781

lacksValue

lacksValue<Parent extends string | object>(
    this: void,
    parent: Parent,
    value: unknown,
): undefined | Parent
Checks that an object/array parent does not include a child value through reference equality.

Performs no type guarding.
Type Parameters
- Parent extends string | object
Parameters
- this: void
- parent: Parent
- value: unknown
Returns undefined | Parent
Example
```
import {checkWrap} from '@augment-vir/assert';

const child = {a: 'a'};

checkWrap.lacksValue({child}, child); // returns `undefined`
checkWrap.lacksValue({child: {a: 'a'}}, child); // returns `{child: {a: 'a'}}`
checkWrap.lacksValue([child], child); // returns `undefined`
```
See
- checkWrap.hasValue : the opposite check.
- checkWrap.lacksValues : the multi-value check.
- Defined in packages/assert/src/assertions/values.ts:1115

lacksValues

lacksValues<Parent extends string | object>(
    this: void,
    parent: Parent,
    values: unknown[],
): undefined | Parent
Checks that an object/array parent includes none of the provided child values through reference equality.

Performs no type guarding.
Type Parameters
- Parent extends string | object
Parameters
- this: void
- parent: Parent
- values: unknown[]
Returns undefined | Parent
Example
```
import {checkWrap} from '@augment-vir/assert';

const child = {a: 'a'};
const child2 = {b: 'b'};

checkWrap.lacksValues({}, [child, child2]); // returns `{}`
checkWrap.lacksValues({child, child2}, [child, child2]); // returns `undefined`
checkWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
```
See
- checkWrap.lacksValues : the opposite check.
- checkWrap.hasValue : the single-value check.
- Defined in packages/assert/src/assertions/values.ts:1182

looseEquals

looseEquals<Actual>(
    this: void,
    actual: Actual,
    expected: unknown,
): undefined | Actual
Checks that two values are loosely equal (using ==). Returns the first value if the check passes, otherwise undefined.

Type guards the first value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- expected: unknown
Returns undefined | Actual
The first value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.looseEquals('a', 'a'); // returns `'a'`

checkWrap.looseEquals('1', 1); // returns `'1'`

checkWrap.looseEquals({a: 'a'}, {a: 'a'}); // returns `undefined`

const objectExample = {a: 'a'};
checkWrap.looseEquals(objectExample, objectExample); // returns `{a: 'a'}`
```
See
- checkWrap.notLooseEquals : the opposite check.
- checkWrap.strictEquals : the strict equality check.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:805

matches

matches(this: void, actual: string, expected: RegExp): undefined | string
Checks that a string (first input, actual) matches a RegExp (second input, expected). Returns the string if the check passes, otherwise undefined.

Performs no type guarding.
Parameters
- this: void
- actual: string
- expected: RegExp
Returns undefined | string
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.matches('hi', /^h/); // returns `'hi'`
checkWrap.matches('hi', /^g/); // returns `undefined`
```
See
- checkWrap.mismatches : the opposite check.
- Defined in packages/assert/src/assertions/regexp.ts:187

mismatches

mismatches(this: void, actual: string, expected: RegExp): undefined | string
Checks that a string (first input, actual) does not match a RegExp (second input, expected). Returns the string if the check passes, otherwise undefined.

Performs no type guarding.
Parameters
- this: void
- actual: string
- expected: RegExp
Returns undefined | string
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.mismatches('hi', /^h/); // returns `undefined`
checkWrap.mismatches('hi', /^g/); // returns `'hi'`
```
See
- checkWrap.matches : the opposite check.
- Defined in packages/assert/src/assertions/regexp.ts:213

notDeepEquals

notDeepEquals<Actual>(
    this: void,
    actual: Actual,
    expected: unknown,
): undefined | Actual
Checks that two values are not deeply equal using the deep-eql package. Returns the first value if the check passes.

Note that this check may be expensive, depending on what values it is passed. Whenever possible, use simpler equality checks instead (see the see section below).

Type guards the first value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- expected: unknown
Returns undefined | Actual
The first value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.deepEquals('a', 'a'); // false

checkWrap.deepEquals('1', 1); // true

checkWrap.deepEquals({a: 'a'}, {a: 'a'}); // false

const objectExample = {a: 'a'};
checkWrap.deepEquals(objectExample, objectExample); // false
```
See
- checkWrap.notDeepEquals : the opposite check.
- checkWrap.entriesEqual : a less expensive (but less thorough) deep equality check.
- checkWrap.jsonEquals : a less expensive (but less thorough) deep equality check.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:919

notEntriesEqual

notEntriesEqual(
    this: void,
    actual: AnyObject,
    expected: AnyObject,
): undefined | AnyObject
Checks that two objects are not deeply equal by checking only their top-level values for strict (non-deep, reference, using ===) equality. If the check passes the first object is returned. If not, undefined is returned.

Performs no type guarding.
Parameters
- this: void
- actual: AnyObject
- expected: AnyObject
Returns undefined | AnyObject
The first input if the assertion passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.notEntriesEqual({a: 'a'}, {a: 'a'}); // returns `undefined`

checkWrap.notEntriesEqual({a: {b: 'b'}}, {a: {b: 'b'}}); // returns `{a: {b: 'b'}}`

const bExample = {b: 'b'};
checkWrap.notEntriesEqual({a: bExample}, {a: bExample}); // returns `undefined`
```
See
- checkWrap.entriesEqual : the opposite check.
- checkWrap.notJsonEquals : another not deep equality check.
- checkWrap.notDeepEquals : the most thorough (but also slow) not deep equality check.
- Defined in packages/assert/src/assertions/equality/entry-equality.ts:443

notInstanceOf

notInstanceOf<const Actual, const Instance>(
    this: void,
    instance: Actual,
    constructor: Constructor<Instance>,
): undefined | Exclude<Actual, Instance>
Checks that a value is not an instance of the given class constructor. Returns the value if the check passes, otherwise undefined.

Type guards the value.
Type Parameters
- const Actual
- const Instance
Parameters
- this: void
- instance: Actual
- constructor: Constructor<Instance>
Returns undefined | Exclude<Actual, Instance>
The value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.notInstanceOf(/abc/, RegExp); // returns `undefined`
checkWrap.notInstanceOf('abc', RegExp); // returns `'abc'`
```
See
- checkWrap.instanceOf : the opposite check.
- Defined in packages/assert/src/assertions/instance.ts:249

notJsonEquals

notJsonEquals<Actual>(
    this: void,
    actual: Actual,
    expected: unknown,
): undefined | Actual
Checks that two values are not deeply equal when stringified into JSON. This may not make any sense if the values are not valid JSON. This internally sorts all given object keys so it is insensitive to object key order. Returns the first value if the check passes.

Performs no type guarding.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- expected: unknown
Returns undefined | Actual
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.notJsonEquals({a: 'a'}, {a: 'a'}); // false

checkWrap.notJsonEquals({a: {b: 'b'}}, {a: {b: 'c'}}); // true
```
See
- checkWrap.jsonEquals : the opposite check.
- checkWrap.entriesEqual : another deep equality check.
- checkWrap.deepEquals : the most thorough (but also slow) deep equality check.
- Defined in packages/assert/src/assertions/equality/json-equality.ts:354

notLooseEquals

notLooseEquals<Actual>(
    this: void,
    actual: Actual,
    expected: unknown,
): undefined | Actual
Checks that two values are not loosely equal (using ==). Returns the first value if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- expected: unknown
Returns undefined | Actual
The first value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.notLooseEquals('a', 'a'); // returns `undefined`

checkWrap.notLooseEquals('1', 1); // returns `undefined`

checkWrap.notLooseEquals({a: 'a'}, {a: 'a'}); // returns `{a: 'a'}`

const objectExample = {a: 'a'};
checkWrap.notLooseEquals(objectExample, objectExample); // returns `undefined`
```
See
- checkWrap.looseEquals : the opposite check.
- checkWrap.strictEquals : the strict equality check.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:839

notStrictEquals

notStrictEquals<Actual>(
    this: void,
    actual: Actual,
    expected: unknown,
): undefined | Actual
Checks that two values are not strictly equal (using ===). Returns the first value if the check passes, otherwise undefined.

Performs no type guarding.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- expected: unknown
Returns undefined | Actual
The first value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.notStrictEquals('a', 'a'); // returns `undefined`

checkWrap.notStrictEquals('1', 1); // returns `'1'`

checkWrap.notStrictEquals({a: 'a'}, {a: 'a'}); // returns `{a: 'a'}`

const objectExample = {a: 'a'};
checkWrap.notStrictEquals(objectExample, objectExample); // returns `undefined`
```
See
- checkWrap.strictEquals : the opposite check.
- checkWrap.notLooseEquals : the loose equality check.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:771

strictEquals

strictEquals<Actual, Expected>(
    this: void,
    actual: Actual,
    expected: Expected,
): undefined | NarrowToExpected<Actual, Expected>
Checks that two values are strictly equal (using ===). Returns the first value if the check passes, otherwise undefined.

Type guards the first value.
Type Parameters
- Actual
- Expected
Parameters
- this: void
- actual: Actual
- expected: Expected
Returns undefined | NarrowToExpected<Actual, Expected>
The first value if the check passes, otherwise undefined.
Example
```
import {checkWrap} from '@augment-vir/assert';

checkWrap.strictEquals('a', 'a'); // returns `'a'`

checkWrap.strictEquals('1', 1); // returns `undefined`

checkWrap.strictEquals({a: 'a'}, {a: 'a'}); // returns `undefined`

const objectExample = {a: 'a'};
checkWrap.strictEquals(objectExample, objectExample); // returns `{a: 'a'}`
```
See
- checkWrap.notStrictEquals : the opposite check.
- checkWrap.looseEquals : the loose equality check.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:733

Function checkWrap

Example

Package

Type Parameters

Parameters

Returns undefined | T

Index

Properties

Methods

Properties

endsWith

Example

Returns

See

endsWithout

Example

Returns

See

isDefined

isLengthAtLeast

Example

Returns

See

isLengthExactly

Example

Returns

See

isNullish

output

Returns

startsWith

Example

Returns

See

startsWithout

Example

Returns

See

throws

Example

Returns

Methods

deepEquals

Type Parameters

Parameters

Returns undefined | NarrowToExpected<Actual, Expected>

Example

See

entriesEqual

Type Parameters

Parameters

Returns undefined | NarrowToExpected<Actual, Expected>

Example

See

hasKey

Type Parameters

Parameters

Returns undefined | CombineTypeWithKey<Key, Parent>

Example

See

hasKeys

Type Parameters

Parameters

Returns undefined | CombineTypeWithKey<Keys, Parent>

Example

See

hasValue

Type Parameters

Parameters

Returns undefined | Parent

Example

See

hasValues

Type Parameters

Parameters

Returns undefined | Parent

Example

See

instanceOf

Type Parameters