Function assert

A group of guard methods that assert their conditions and do nothing else.

This can also be called as a standalone assertion function which asserts that its input is truthy.

Example

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

const value: unknown = 'some value' as unknown;
assert.isString(value);
// `value` will now be typed as a `string`

Throws

AssertionError When the assertion fails.

Package

@augment-vir/assert

assert(input: unknown, failureMessage?: string): void
Parameters
- input: unknown
- OptionalfailureMessage: string
Returns void
- Defined in packages/assert/src/augments/guards/assert.ts:53

Index

Properties

endsWith endsWithout fail isError isLengthAtLeast isLengthExactly output startsWith startsWithout throws tsType

Methods

deepEquals entriesEqual hasKey hasKeys hasValue hasValues instanceOf isAbove isApproximately isArray isAtLeast isAtMost isBelow isBigInt isBoolean isDefined isEmpty isEnumValue 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 isNotUndefined isNotUuid isNull isNullish isNumber isObject isOutBounds isPrimitive isPromise isPromiseLike isPropertyKey isString isSymbol isTrue isTruthy isUndefined 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,
    ): void;
    (parent: string, child: string, failureMessage?: string): void;
    (
        parent: string | readonly string[],
        child: string,
        failureMessage?: string,
    ): void;
}

Asserts that a parent string or array ends with a specific child. This uses reference equality when the parent is an array.

Performs no type guarding.

Example

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

assert.endsWith('ab', 'b'); // passes
assert.endsWith('ab', 'a'); // fails
assert.endsWith(['a', 'b'], 'b'); // passes
assert.endsWith(['a', 'b'], 'a'); // fails

Throws

AssertionError If the parent does not end with the child.

See

assert.endsWithout : the opposite assertion.
assert.startsWith : assertion on the other end.

endsWithout

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

Asserts that a parent string or array does not end with a specific child. This uses reference equality when the parent is an array.

Performs no type guarding.

Example

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

assert.endsWithout('ab', 'b'); // fails
assert.endsWithout('ab', 'a'); // passes
assert.endsWithout(['a', 'b'], 'b'); // fails
assert.endsWithout(['a', 'b'], 'a'); // passes

Throws

AssertionError If the parent ends with the child.

See

assert.endsWith : the opposite assertion.
assert.startsWithout : assertion on the other end.

fail

fail: (failureMessage?: string) => never = ...

Immediately throw an assertion error.

Example

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

assert.fail(); // throws an `AssertionError`

Throws

AssertionError

isError

isError: (
    this: void,
    actual: unknown,
    matchOptions?: PartialWithNullable<
        {
            matchConstructor: ErrorConstructor
            | new (...args: any[]) => Error;
            matchMessage: string | RegExp;
        },
    >,
    failureMessage?: string,
) => asserts actual is Error

Asserts that a value is an instance of the built-in Error class and compares it to the given ErrorMatchOptions, if provided.

Type guards the input.

Example

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

assert.isError(new Error()); // passes
assert.isError(new Error(), {matchMessage: 'hi'}); // fails
assert.isError({message: 'not an error'}); // fails

Throws

AssertionError If the assertion fails.

isLengthAtLeast

isLengthAtLeast: {
    <const Element, const Length extends number>(
        actual: readonly (undefined | Element)[],
        length: Length,
        failureMessage?: string,
    ): asserts actual is readonly [Tuple<Element, Length>, Element];
    (actual: string | AnyObject, length: number, failureMessage?: string): void;
}

Asserts that an array or string has at least the given length.

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

Example

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

assert.isLengthAtLeast(['a', 'b', 'c'], 2); // passes
assert.isLengthAtLeast(['a', 'b', 'c'], 3); // passes
assert.isLengthAtLeast(['a', 'b'], 3); // fails

Throws

AssertionError If the value is less than the given length.

See

assert.isLengthExactly : the more exact assertion.

isLengthExactly

isLengthExactly: {
    <const Element, const Length extends number>(
        actual: readonly (undefined | Element)[],
        length: Length,
        failureMessage?: string,
    ): asserts actual is Tuple<Element, Length>;
    (actual: string | AnyObject, length: number, failureMessage?: string): void;
}

Asserts that an array or string has exactly the given length.

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

Example

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

assert.isLengthExactly(['a', 'b', 'c'], 2); // fails
assert.isLengthExactly(['a', 'b', 'c'], 3); // passes
assert.isLengthExactly(['a', 'b'], 3); // fails

Throws

AssertionError If the value is not exactly the given length.

See

assert.isLengthAtLeast : the more flexible assertion.

output

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

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 "deeply equals" to whatever you want.

Performs no type guarding.

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

assert.output((input: number) => String(input), [5], '5'); // passes
assert.output((input: number) => String(input), [10], '5'); // fails

assert.output(assert.isLengthAtLeast, (input: number) => String(input), [5], 2); // fails
assert.output(assert.isLengthAtLeast, (input: number) => String(input), [10], 2); // passes

Throws

AssertionError If the assertion fails.

startsWith

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

Asserts that a parent string or array starts with a specific child. This uses reference equality when the parent is an array.

Performs no type guarding.

Example

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

assert.startsWith('ab', 'b'); // fails
assert.startsWith('ab', 'a'); // passes
assert.startsWith(['a', 'b'], 'b'); // fails
assert.startsWith(['a', 'b'], 'a'); // passes

Throws

AssertionError If the parent does not start with the child.

See

assert.startsWithout : the opposite assertion.
assert.endsWith : assertion on the other end.

startsWithout

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

Asserts that a parent string or array starts with a specific child. This uses reference equality when the parent is an array.

Performs no type guarding.

Example

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

assert.startsWith('ab', 'b'); // passes
assert.startsWith('ab', 'a'); // fails
assert.startsWith(['a', 'b'], 'b'); // passes
assert.startsWith(['a', 'b'], 'a'); // fails

Throws

AssertionError If the parent does start with the child.

See

assert.startsWithout : the opposite assertion.
assert.endsWith : assertion on the other end.

throws

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

If a function input is provided:

Calls that function and asserts that the function throw an error, comparing the error with the given ErrorMatchOptions, if provided.

If a promise is provided:

Awaits the promise and asserts that the promise rejected with an error, comparing the error with the given ErrorMatchOptions, if provided.

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 {assert} from '@augment-vir/assert';

assert.throws(() => {
    throw new Error();
}); // passes
assert.throws(
    () => {
        throw new Error();
    },
    {matchMessage: 'hi'},
); // fails
await assert.throws(Promise.reject()); // passes
assert.throws(() => {}); // fails

Throws

AssertionError If the assertion fails.

tsType

tsType: {
<Actual>(input: Actual): AssertTypeOf<Actual>;
<Actual>(): AssertTypeOf<Actual>;
}

Asserts within the TypeScript type system that a given type or value matches type expectations (using the expect-type package. Make sure to call a method on the first call to actually assert anything.

Use this to write type tests. Don't use this in production code. It won't cause issues, but it's a useless no-op at run-time (it's not even a type guard).

Performs no type guarding.

Type declaration

- <Actual>(input: Actual): AssertTypeOf<Actual>
- Type Parameters
  - Actual
  Parameters
  - input: Actual
    Run-time value to type check.
  Returns AssertTypeOf<Actual>
- <Actual>(): AssertTypeOf<Actual>
- Uses the expect-type package to assert type matching.
  Type Parameters
  - Actual
  Returns AssertTypeOf<Actual>

Example

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

assert.tsType('hello').equals<string>();
assert.tsType<'hello>().equals<'hello'>();
assert.tsType<'hello>().notEquals<string>();
assert.tsType('hello').notEquals<number>();

Returns

Never returns anything.

Throws

Never throws anything.

Methods

deepEquals

deepEquals<const Actual, const Expected>(
    this: void,
    actual: Actual,
    expected: Expected,
    failureMessage?: string,
): asserts actual is NarrowToExpected<Actual, Expected>
Asserts that two values are deeply equal using the deep-eql package.

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
- const Actual
- const Expected
Parameters
- this: void
- actual: Actual
- expected: Expected
- OptionalfailureMessage: string
Returns asserts actual is NarrowToExpected<Actual, Expected>
Example
```
import {assert} from '@augment-vir/assert';

assert.deepEquals('a', 'a'); // passes

assert.deepEquals('1', 1); // fails

assert.deepEquals({a: 'a'}, {a: 'a'}); // passes

const objectExample = {a: 'a'};
assert.deepEquals(objectExample, objectExample); // passes
```
Throws
AssertionError If both inputs are not deeply equal.
See
- assert.notDeepEquals : the opposite assertion.
- assert.entriesEqual : a less expensive (but less thorough) deep equality assertion.
- assert.jsonEquals : a less expensive (but less thorough) deep equality assertion.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:194

entriesEqual

entriesEqual<Actual extends AnyObject, const Expected extends AnyObject>(
    this: void,
    actual: Actual,
    expected: Expected,
    failureMessage?: string,
): asserts actual is Expected
Asserts that two objects are deeply equal by checking only their top-level values for strict (non-deep, reference, using ===) equality.

Type guards the first value.
Type Parameters
- Actual extends AnyObject
- const Expected extends AnyObject
Parameters
- this: void
- actual: Actual
- expected: Expected
- OptionalfailureMessage: string
Returns asserts actual is Expected
Example
```
import {assert} from '@augment-vir/assert';

assert.entriesEqual({a: 'a'}, {a: 'a'}); // passes

assert.entriesEqual({a: {b: 'b'}}, {a: {b: 'b'}}); // fails

const bExample = {b: 'b'};
assert.entriesEqual({a: bExample}, {a: bExample}); // passes
```
Throws
AssertionError If both inputs are not equal.
See
- assert.notEntriesEqual : the opposite assertion.
- assert.jsonEquals : another deep equality assertion.
- assert.deepEquals : the most thorough (but also slow) deep equality assertion.
- Defined in packages/assert/src/assertions/equality/entry-equality.ts:35

hasKey

hasKey<const Key extends PropertyKey, const Parent>(
    this: void,
    parent: Parent,
    key: Key,
    failureMessage?: string,
): asserts parent is CombineTypeWithKey<Key, Parent>
Asserts that a parent value has the key.

Type guards the parent value.
Type Parameters
- const Key extends PropertyKey
- const Parent
Parameters
- this: void
- parent: Parent
- key: Key
- OptionalfailureMessage: string
Returns asserts parent is CombineTypeWithKey<Key, Parent>
Example
```
import {assert} from '@augment-vir/assert';

assert.hasKey({a: 0, b: 1}, 'a'); // passes
assert.hasKey({a: 0, b: 1}, 'c'); // fails
```
Throws
AssertionError If the parent does not have the key.
See
- assert.lacksKey : the opposite assertion.
- assert.hasKeys : the multi-key assertion.
- Defined in packages/assert/src/assertions/keys.ts:133

hasKeys

hasKeys<const Keys extends PropertyKey, const Parent>(
    this: void,
    parent: Parent,
    keys: readonly Keys[],
    failureMessage?: string,
): asserts parent is CombineTypeWithKey<Keys, Parent>
Asserts that a parent value has all the keys.

Type guards the parent value.
Type Parameters
- const Keys extends PropertyKey
- const Parent
Parameters
- this: void
- parent: Parent
- keys: readonly Keys[]
- OptionalfailureMessage: string
Returns asserts parent is CombineTypeWithKey<Keys, Parent>
Example
```
import {assert} from '@augment-vir/assert';

assert.hasKeys({a: 0, b: 1}, ['a', 'b']); // passes
assert.hasKeys({a: 0, b: 1}, ['b', 'c']); // fails
```
Throws
AssertionError If the parent does not have all the keys.
See
- assert.lacksKeys : the opposite assertion.
- assert.hasKey : the single-key assertion.
- Defined in packages/assert/src/assertions/keys.ts:197

hasValue

hasValue(
    this: void,
    parent: string | object,
    value: unknown,
    failureMessage?: string,
): void
Asserts that an object/array parent includes a child value through reference equality.

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

const child = {a: 'a'};

assert.hasValue({child}, child); // passes
assert.hasValue({child: {a: 'a'}}, child); // fails
assert.hasValue([child], child); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.lacksValue : the opposite assertion.
- assert.hasValues : the multi-value assertion.
- Defined in packages/assert/src/assertions/values.ts:81

hasValues

hasValues(
    this: void,
    parent: string | object,
    values: unknown[],
    failureMessage?: string,
): void
Asserts that an object/array parent includes all child values through reference equality.

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

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

assert.hasValues({child, child2}, [child, child2]); // passes
assert.hasValues({child: {a: 'a'}, child2}, [child, child2]); // fails
assert.hasValues([child], [child, child2]); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.lacksValues : the opposite assertion.
- assert.hasValue : the single-value assertion.
- Defined in packages/assert/src/assertions/values.ts:154

instanceOf

instanceOf<const Instance>(
    this: void,
    instance: unknown,
    constructor: Constructor<Instance>,
    failureMessage?: string,
): asserts instance is Instance
Asserts that a value is an instance of the given class constructor.

Type guards the value.
Type Parameters
- const Instance
Parameters
- this: void
- instance: unknown
- constructor: Constructor<Instance>
  The constructor that the "instance" input will be checked against.
- OptionalfailureMessage: string
  Message to include in error message if this assertion fails.
Returns asserts instance is Instance
Example
```
import {assert} from '@augment-vir/assert';

assert.instanceOf(/abc/, RegExp); // passes
assert.instanceOf('abc', RegExp); // fails
```
Throws
AssertionError If the value is not an instance of the given class constructor.
See
- assert.notInstanceOf : the opposite assertion.
- Defined in packages/assert/src/assertions/instance.ts:27

isAbove

isAbove(
    this: void,
    actual: number,
    expected: number,
    failureMessage?: string,
): void
Asserts that a number is above the expectation (actual > expected).

Performs no type guarding.
Parameters
- this: void
- actual: number
- expected: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isAbove(10, 5); // passes
assert.isAbove(5, 5); // fails
assert.isAbove(5, 10); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isBelow : the opposite assertion.
- assert.isAtLeast : the more lenient assertion.
- Defined in packages/assert/src/assertions/numeric.ts:146

isApproximately

isApproximately(
    this: void,
    actual: number,
    expected: number,
    delta: number,
    failureMessage?: string,
): void
Asserts that a number is within ±delta of the expectation.

Performs no type guarding.
Parameters
- this: void
- actual: number
- expected: number
- delta: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isApproximately(10, 8, 4); // passes
assert.isApproximately(10, 12, 4); // passes
assert.isApproximately(10, 8, 1); // fails
assert.isApproximately(10, 12, 1); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotApproximately : the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:324

isArray

isArray<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is ArrayNarrow<Actual>
Asserts that a value is an array.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is ArrayNarrow<Actual>
Example
```
import {assert} from '@augment-vir/assert';

assert.isArray([]); // passes
assert.isArray({length: 4}); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotArray : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:41

isAtLeast

isAtLeast(
    this: void,
    actual: number,
    expected: number,
    failureMessage?: string,
): void
Asserts that a number is at least the expectation (actual >= expected).

Performs no type guarding.
Parameters
- this: void
- actual: number
- expected: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isAtLeast(10, 5); // passes
assert.isAtLeast(5, 5); // passes
assert.isAtLeast(5, 10); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isAtMost : the opposite assertion.
- assert.isAbove : the more restrictive assertion.
- Defined in packages/assert/src/assertions/numeric.ts:171

isAtMost

isAtMost(
    this: void,
    actual: number,
    expected: number,
    failureMessage?: string,
): void
Asserts that a number is at most the expectation (actual <= expected).

Performs no type guarding.
Parameters
- this: void
- actual: number
- expected: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isAtMost(10, 5); // fails
assert.isAtMost(5, 5); // passes
assert.isAtMost(5, 10); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isAtLeast : the opposite assertion.
- assert.isBelow : the more restrictive assertion.
- Defined in packages/assert/src/assertions/numeric.ts:221

isBelow

isBelow(
    this: void,
    actual: number,
    expected: number,
    failureMessage?: string,
): void
Asserts that a number is below the expectation (actual < expected).

Performs no type guarding.
Parameters
- this: void
- actual: number
- expected: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isBelow(10, 5); // fails
assert.isBelow(5, 5); // fails
assert.isBelow(5, 10); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isAbove : the opposite assertion.
- assert.isAtMost : the more lenient assertion.
- Defined in packages/assert/src/assertions/numeric.ts:196

isBigInt

isBigInt(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is bigint
Asserts that a value is a BigInt.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is bigint
Example
```
import {assert} from '@augment-vir/assert';

assert.isBigInt(123n); // passes
assert.isBigInt(123); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotBigInt : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:68

isBoolean

isBoolean(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is boolean
Asserts that a value is a boolean.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is boolean
Example
```
import {assert} from '@augment-vir/assert';

assert.isBoolean(true); // passes
assert.isBoolean('true'); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotBoolean : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:95

isDefined

isDefined<const Actual>(
    this: void,
    input: Actual,
    failureMessage?: string,
): asserts input is Exclude<Actual, undefined | null>
Asserts that a value is defined (not null and not undefined).

Type guards the value.
Type Parameters
- const Actual
Parameters
- this: void
- input: Actual
  The value to check.
- OptionalfailureMessage: string
  Message to include in error message if this assertion fails.
Returns asserts input is Exclude<Actual, undefined | null>
Example
```
import {assert} from '@augment-vir/assert';

assert.isDefined(0); // passes
assert.isDefined(''); // passes
assert.isDefined(null); // fails
assert.isDefined(undefined); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNullish : the opposite assertion.
- Defined in packages/assert/src/assertions/nullish.ts:27

isEmpty

isEmpty<Actual extends CanBeEmpty>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is NarrowToActual<Actual, Empty>
Asserts 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
- OptionalfailureMessage: string
Returns asserts actual is NarrowToActual<Actual, Empty>
Example
```
import {assert} from '@augment-vir/assert';

assert.isEmpty({}); // passes
assert.isEmpty(''); // passes
assert.isEmpty([]); // passes

assert.isEmpty('a'); // fails
assert.isEmpty({a: 'a'}); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotEmpty : the opposite assertion.
- Defined in packages/assert/src/assertions/values.ts:346

isEnumValue

isEnumValue<const Expected extends EnumBaseType>(
    this: void,
    child: unknown,
    checkEnum: Expected,
    failureMessage?: string,
): asserts child is Expected[keyof Expected]
Asserts that a child value is an enum member.

Type guards the child value.
Type Parameters
- const Expected extends EnumBaseType
Parameters
- this: void
- child: unknown
- checkEnum: Expected
- OptionalfailureMessage: string
Returns asserts child is Expected[keyof Expected]
Example
```
import {assert} from '@augment-vir/assert';

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

assert.isEnumValue('a', MyEnum); // passes
assert.isEnumValue('A', MyEnum); // fails
```
Throws
AssertionError If the child is not an enum member.
See
- assert.isNotEnumValue : the opposite assertion.
- Defined in packages/assert/src/assertions/enum.ts:55

isFalse

isFalse(
    this: void,
    input: unknown,
    failureMessage?: string,
): asserts input is false
Asserts that a value is exactly false.

Type guards the value.
Parameters
- this: void
- input: unknown
- OptionalfailureMessage: string
Returns asserts input is false
Example
```
import {assert} from '@augment-vir/assert';

assert.isFalse(true); // fails
assert.isFalse(false); // passes
assert.isFalse(1); // fails
assert.isFalse(0); // fails
```
Throws
AssertionError If the value is not false.
See
- assert.isTrue : the opposite assertion.
- assert.isFalsy : a less exact assertion.
- Defined in packages/assert/src/assertions/boolean.ts:81

isFalsy

isFalsy(
    this: void,
    input: unknown,
    failureMessage?: string,
): asserts input is FalsyValue
Asserts that a value is falsy.

Type guards the value when possible.
Parameters
- this: void
- input: unknown
- OptionalfailureMessage: string
Returns asserts input is FalsyValue
Example
```
import {assert} from '@augment-vir/assert';

assert.isFalsy(true); // fails
assert.isFalsy(false); // passes
assert.isFalsy(1); // fails
assert.isFalsy(0); // passes
```
Throws
AssertionError If the value is not falsy.
See
- assert.isTruthy : the opposite assertion.
- assert.isFalse : a more exact assertion.
- Defined in packages/assert/src/assertions/boolean.ts:111

isFinite

isFinite(this: void, actual: number, failureMessage?: string): void
Asserts that a number is finite: meaning, not NaN and not Infinity or -Infinity.

Performs no type guarding.
Parameters
- this: void
- actual: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isFinite(10); // passes
assert.isFinite(parseInt('invalid')); // fails
assert.isFinite(Infinity); // fails
assert.isFinite(-Infinity); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNaN : an opposite assertion.
- assert.isInfinite : an opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:273

isFunction

isFunction<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is NarrowToActual<Actual, AnyFunction>
Asserts that a value is a function.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is NarrowToActual<Actual, AnyFunction>
Example
```
import {assert} from '@augment-vir/assert';

assert.isFunction(() => {}); // passes
assert.isFunction({}); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:122

isHttpStatus

isHttpStatus<Actual>(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is NarrowToExpected<Actual, HttpStatus>
Asserts that a value is an HttpStatus.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is NarrowToExpected<Actual, HttpStatus>
Example
```
import {assert} from '@augment-vir/assert';

assert.isHttpStatus(400); // passes
assert.isHttpStatus(500); // passes
assert.isHttpStatus(99); // fails
```
Throws
AssertionError If the value is not an HttpStatus.
See
- assert.isHttpStatusCategory : the category assertion.
- HttpStatus : all included statuses.
- HttpStatusCategory : all status categories.
- Defined in packages/assert/src/assertions/http.ts:38

isHttpStatusCategory

isHttpStatusCategory<const Actual, const Category extends HttpStatusCategory>(
    this: void,
    actual: Actual,
    category: Category,
    failureMessage?: string,
): asserts actual is NarrowToExpected<
    Actual,
    HttpStatusByCategory<Category>,
>
Asserts that a value is an HttpStatus within a specific HttpStatusCategory.

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

assert.isHttpStatusCategory(400, HttpStatusCategory.ClientError); // passes
assert.isHttpStatusCategory(500, HttpStatusCategory.Success); // fails
assert.isHttpStatusCategory(99, HttpStatusCategory.Information); // fails
```
Throws
AssertionError If the value is not an HttpStatus within the HttpStatusCategory.
See
- assert.isHttpStatus : the status assertion.
- HttpStatus : all included statuses.
- HttpStatusCategory : all status categories.
- Defined in packages/assert/src/assertions/http.ts:72

isIn

isIn<Parent extends string | object>(
    this: void,
    child: unknown,
    parent: Parent,
    failureMessage?: string,
): asserts child is Values<Parent>
Asserts 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
Parameters
- this: void
- child: unknown
- parent: Parent
- OptionalfailureMessage: string
Returns asserts child is Values<Parent>
Example
```
import {assert} from '@augment-vir/assert';

const child = {a: 'a'};

assert.isIn(child, {child}); // passes
assert.isIn('a', 'ab'); // passes
assert.isIn(child, [child]); // passes

assert.isIn(child, {child: {a: 'a'}}); // fails
assert.isIn('a', 'bc'); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotIn : the opposite assertion.
- Defined in packages/assert/src/assertions/values.ts:273

isInBounds

isInBounds(
    this: void,
    actual: number,
    __namedParameters: MinMax,
    failureMessage?: string,
): void
Asserts that a number is inside the provided min and max bounds, inclusive.

Performs no type guarding.
Parameters
- this: void
- actual: number
- __namedParameters: MinMax
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isInBounds(5, {min: 1, max: 10}); // passes
assert.isInBounds(10, {min: 1, max: 10}); // passes
assert.isInBounds(11, {min: 1, max: 10}); // fails
assert.isInBounds(0, {min: 1, max: 10}); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isOutBounds : the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:27

isInfinite

isInfinite(this: void, actual: number, failureMessage?: string): void
Asserts that a number is either Infinity or -Infinity.

Performs no type guarding.
Parameters
- this: void
- actual: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isInfinite(10); // fails
assert.isInfinite(parseInt('invalid')); // fails
assert.isInfinite(Infinity); // passes
assert.isInfinite(-Infinity); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isNaN : an opposite assertion.
- assert.isInfinite : an opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:299

isInteger

isInteger(this: void, actual: number, failureMessage?: string): void
Asserts that a number is an integer. This has the same limitations as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.

Performs no type guarding.
Parameters
- this: void
- actual: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isInteger(5); // passes
assert.isInteger(5.0000000000000001); // passes
assert.isInteger(5.1); // fails
assert.isInteger(NaN); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotInteger : the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:95

isKeyOf

isKeyOf<const Parent>(
    this: void,
    key: PropertyKey,
    parent: Parent,
    failureMessage?: string,
): asserts key is keyof Parent
Asserts that a key is contained within a parent value.

Type guards the key.
Type Parameters
- const Parent
Parameters
- this: void
- key: PropertyKey
- parent: Parent
- OptionalfailureMessage: string
Returns asserts key is keyof Parent
Example
```
import {assert} from '@augment-vir/assert';

assert.isKeyof('a', {a: 0, b: 1}); // passes
assert.isKeyof('c', {a: 0, b: 1}); // fails
```
Throws
AssertionError If the key is not in the parent.
See
- assert.isNotKeyOf : the opposite assertion.
- Defined in packages/assert/src/assertions/keys.ts:70

isNaN

isNaN(this: void, actual: number, failureMessage?: string): void
Asserts that a number is NaN.

Performs no type guarding.
Parameters
- this: void
- actual: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isNaN(10); // fails
assert.isNaN(parseInt('invalid')); // passes
assert.isNaN(Infinity); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNumber : can be used as the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:247

isNotApproximately

isNotApproximately(
    this: void,
    actual: number,
    expected: number,
    delta: number,
    failureMessage?: string,
): void
Asserts that a number is outside ±delta of the expectation.

Performs no type guarding.
Parameters
- this: void
- actual: number
- expected: number
- delta: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotApproximately(10, 8, 4); // fails
assert.isNotApproximately(10, 12, 4); // fails
assert.isNotApproximately(10, 8, 1); // passes
assert.isNotApproximately(10, 12, 1); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isApproximately : the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:358

isNotArray

isNotArray<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, readonly unknown[]>
Asserts that a value is not an array.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, readonly unknown[]>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotArray([]); // fails
assert.isNotArray({length: 4}); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isArray : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:315

isNotBigInt

isNotBigInt<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, bigint>
Asserts that a value is not a BigInt.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, bigint>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotBigInt(123n); // fails
assert.isNotBigInt(123); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isBigInt : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:342

isNotBoolean

isNotBoolean<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, boolean>
Asserts that a value is not a boolean.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, boolean>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotBoolean(true); // fails
assert.isNotBoolean('true'); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isBoolean : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:369

isNotEmpty

isNotEmpty<Actual extends CanBeEmpty>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, Empty>
Asserts 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
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, Empty>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotEmpty({}); // fails
assert.isNotEmpty(''); // fails
assert.isNotEmpty([]); // fails

assert.isNotEmpty('a'); // passes
assert.isNotEmpty({a: 'a'}); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isEmpty : the opposite assertion.
- Defined in packages/assert/src/assertions/values.ts:396

isNotEnumValue

isNotEnumValue<const Actual, const Expected extends EnumBaseType>(
    this: void,
    child: Actual,
    checkEnum: Expected,
    failureMessage?: string,
): asserts child is Exclude<
    Actual,
    Expected[keyof Expected]
    | `${Expected[keyof Expected]}`,
>
Asserts that a child value is not an enum member.

Type guards the child value.
Type Parameters
- const Actual
- const Expected extends EnumBaseType
Parameters
- this: void
- child: Actual
- checkEnum: Expected
- OptionalfailureMessage: string
Returns asserts child is Exclude<
    Actual,
    Expected[keyof Expected]
    | `${Expected[keyof Expected]}`,
>
Example
```
import {assert} from '@augment-vir/assert';

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

assert.isNotEnumValue('a', MyEnum); // fails
assert.isNotEnumValue('A', MyEnum); // passes
```
Throws
AssertionError If the child is an enum member.
See
- assert.isEnumValue : the opposite assertion.
- Defined in packages/assert/src/assertions/enum.ts:86

isNotFunction

isNotFunction<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, AnyFunction>
Asserts that a value is not a function.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, AnyFunction>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotFunction(() => {}); // fails
assert.isNotFunction({}); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:396

isNotIn

isNotIn<Parent extends string | object, Child>(
    this: void,
    child: Child,
    parent: Parent,
    failureMessage?: string,
): asserts child is Exclude<Child, Values<Parent>>
Asserts 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
- OptionalfailureMessage: string
Returns asserts child is Exclude<Child, Values<Parent>>
Example
```
import {assert} from '@augment-vir/assert';

const child = {a: 'a'};

assert.isNotIn(child, {child}); // fails
assert.isNotIn('a', 'ab'); // fails
assert.isNotIn(child, [child]); // fails

assert.isNotIn(child, {child: {a: 'a'}}); // passes
assert.isNotIn('a', 'bc'); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isIn : the opposite assertion.
- Defined in packages/assert/src/assertions/values.ts:311

isNotInteger

isNotInteger(this: void, actual: number, failureMessage?: string): void
Asserts that a number is not an integer. This has the same limitations, as https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger.

Performs no type guarding.
Parameters
- this: void
- actual: number
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotInteger(5); // fails
assert.isNotInteger(5.0000000000000001); // fails
assert.isNotInteger(5.1); // passes
assert.isNotInteger(NaN); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isInteger : the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:121

isNotKeyOf

isNotKeyOf<const Key extends PropertyKey, const Parent>(
    this: void,
    key: Key,
    parent: Parent,
    failureMessage?: string,
): asserts key is Exclude<Key, RequiredKeysOf<Parent>>
Asserts that a key is not contained within a parent value.

Type guards the key.
Type Parameters
- const Key extends PropertyKey
- const Parent
Parameters
- this: void
- key: Key
- parent: Parent
- OptionalfailureMessage: string
Returns asserts key is Exclude<Key, RequiredKeysOf<Parent>>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotKeyOf('a', {a: 0, b: 1}); // fails
assert.isNotKeyOf('c', {a: 0, b: 1}); // passes
```
Throws
AssertionError If the key is in the parent.
See
- assert.isKeyOf : the opposite assertion.
- Defined in packages/assert/src/assertions/keys.ts:101

isNotNull

isNotNull<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, null>
Asserts that a value is not exactly null.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, null>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotNull(null); // fails
assert.isNotNull(undefined); // passes
```
Throws
AssertionError If the assertion failed.
See
- - assert.isFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:423

isNotNumber

isNotNumber<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, number>
Asserts that a value is not a number. This includes NaN.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, number>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotNumber(123); // fails
assert.isNotNumber(123n); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:450

isNotObject

isNotObject<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, UnknownObject>
Asserts that a value is not an object. This includes arrays.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, UnknownObject>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotObject({}); // fails
assert.isNotObject([]); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:477

isNotPrimitive

isNotPrimitive<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, Primitive>
Asserts that a value is not a JavaScript primitive.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, Primitive>
Example
```
import {assert} from '@augment-vir/assert';

assert.isPrimitive('key'); // fails
assert.isPrimitive(true); // fails
assert.isPrimitive({}); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isPrimitive : the opposite assertion.
- Defined in packages/assert/src/assertions/primitive.ts:133

isNotPromise

isNotPromise<const Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, Promise<any>>

Asserts that a value is a not Promise instance.

Type guards the value.

Type Parameters

const Actual

Parameters

this: void
actual: Actual
OptionalfailureMessage: string

Returns asserts actual is Exclude<Actual, Promise<any>>

Example

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

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

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

assert.isNotPromise(Promise.resolve(5)); // fails
assert.isNotPromise(new CustomThenable(5)); // passes
assert.isNotPromise(5); // passes

Throws

AssertionError If the assertion fails.

See

assert.isPromise : the opposite assertion.
assert.isNotPromiseLike : the more lenient assertion.

isNotPromiseLike

isNotPromiseLike<const Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, PromiseLike<any>>
Asserts that a value is not a PromiseLike.

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
- const Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, PromiseLike<any>>
Example
```
import {assert} from '@augment-vir/assert';

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

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

assert.isNotPromiseLike(Promise.resolve(5)); // fails
assert.isNotPromiseLike(new CustomThenable(5)); // fails
assert.isNotPromiseLike(5); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isPromiseLike : the opposite assertion.
- assert.isNotPromise : the more precise assertion.
- Defined in packages/assert/src/assertions/promise.ts:91

isNotPropertyKey

isNotPropertyKey<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, PropertyKey>
Asserts 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.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, PropertyKey>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotPropertyKey('key'); // fails
assert.isNotPropertyKey(true); // passes
assert.isNotPropertyKey({}); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isPropertyKey : the opposite assertion.
- Defined in packages/assert/src/assertions/primitive.ts:66

isNotString

isNotString<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, string>
Asserts that a value is not a string.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, string>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotString(''); // fails
assert.isNotString(5); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:507

isNotSymbol

isNotSymbol<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, symbol>
Asserts that a value is not a symbol.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, symbol>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotSymbol(Symbol('my-symbol')); // fails
assert.isNotSymbol('my-symbol'); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:534

isNotUndefined

isNotUndefined<Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<Actual, undefined>
Asserts that a value is not exactly undefined.

Type guards the value.
Type Parameters
- Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<Actual, undefined>
Example
```
import {assert} from '@augment-vir/assert';

assert.isNotUndefined(undefined); // fails
assert.isNotUndefined(null); // passes
```
Throws
AssertionError If the assertion failed.
See
- assert.isFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:561

isNotUuid

isNotUuid<const Actual>(
    this: void,
    actual: Actual,
    failureMessage?: string,
): asserts actual is Exclude<
    Actual,
    `${string}-${string}-${string}-${string}-${string}`,
>
Asserts that a value is not a valid UUID. The nil or max UUIDs are included as not valid.

Type guards the value.
Type Parameters
- const Actual
Parameters
- this: void
- actual: Actual
- OptionalfailureMessage: string
Returns asserts actual is Exclude<
Actual,
`${string}-${string}-${string}-${string}-${string}`,
>
Example
```
import {assert} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';

assert.isNotUuid(createUuidV4()); // fails
assert.isNotUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // fails
assert.isNotUuid('00000000-0000-0000-0000-000000000000'); // passes
assert.isNotUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // passes
assert.isNotUuid('not-a-uuid'); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isUuid : the opposite assertion.
- Defined in packages/assert/src/assertions/uuid.ts:62

isNull

isNull(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is null
Asserts that a value is exactly null.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is null
Example
```
import {assert} from '@augment-vir/assert';

assert.isNull(null); // passes
assert.isNull(undefined); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:149

isNullish

isNullish(
    this: void,
    input: unknown,
    failureMessage?: string,
): asserts input is undefined | null
Asserts that a value is nullish (null or undefined).

Type guards the value.
Parameters
- this: void
- input: unknown
  The value to check.
- OptionalfailureMessage: string
  Message to include in error message if this assertion fails.
Returns asserts input is undefined | null
Example
```
import {assert} from '@augment-vir/assert';

assert.isNullish(0); // fails
assert.isNullish(''); // fails
assert.isNullish(null); // passes
assert.isNullish(undefined); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isDefined : the opposite assertion.
- Defined in packages/assert/src/assertions/nullish.ts:58

isNumber

isNumber(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is number
Asserts that a value is a number. This excludes NaN.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is number
Example
```
import {assert} from '@augment-vir/assert';

assert.isNumber(123); // passes
assert.isNumber(123n); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:176

isObject

isObject(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is UnknownObject
Asserts that a value is an object. This excludes arrays.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is UnknownObject
Example
```
import {assert} from '@augment-vir/assert';

assert.isObject({}); // passes
assert.isObject([]); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:203

isOutBounds

isOutBounds(
    this: void,
    actual: number,
    __namedParameters: MinMax,
    failureMessage?: string,
): void
Asserts that a number is outside the provided min and max bounds, exclusive.

Performs no type guarding.
Parameters
- this: void
- actual: number
- __namedParameters: MinMax
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.isOutBounds(5, {min: 1, max: 10}); // fails
assert.isOutBounds(10, {min: 1, max: 10}); // fails
assert.isOutBounds(11, {min: 1, max: 10}); // passes
assert.isOutBounds(0, {min: 1, max: 10}); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.isInBounds : the opposite assertion.
- Defined in packages/assert/src/assertions/numeric.ts:60

isPrimitive

isPrimitive(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is Primitive
Asserts that a value is a JavaScript primitive.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is Primitive
Example
```
import {assert} from '@augment-vir/assert';

assert.isPrimitive('key'); // passes
assert.isPrimitive(true); // passes
assert.isPrimitive({}); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotPrimitive : the opposite assertion.
- Defined in packages/assert/src/assertions/primitive.ts:100

isPromise

isPromise(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is Promise<any>

Asserts that a value is a Promise instance.

Type guards the value.

Parameters

this: void
actual: unknown
OptionalfailureMessage: string

Returns asserts actual is Promise<any>

Example

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

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

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

assert.isPromise(Promise.resolve(5)); // passes
assert.isPromise(new CustomThenable(5)); // fails
assert.isPromise(5); // fails

Throws

AssertionError If the assertion fails.

See

assert.isNotPromise : the opposite assertion.
assert.isPromiseLike : the more lenient assertion.

isPromiseLike

isPromiseLike(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is PromiseLike<any>
Asserts that a value is a PromiseLike.

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.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is PromiseLike<any>
Example
```
import {assert} from '@augment-vir/assert';

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

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

assert.isPromiseLike(Promise.resolve(5)); // passes
assert.isPromiseLike(new CustomThenable(5)); // passes
assert.isPromiseLike(5); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotPromiseLike : the opposite assertion.
- assert.isPromise : the more precise assertion.
- Defined in packages/assert/src/assertions/promise.ts:39

isPropertyKey

isPropertyKey(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is PropertyKey
Asserts 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.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is PropertyKey
Example
```
import {assert} from '@augment-vir/assert';

assert.isPropertyKey('key'); // passes
assert.isPropertyKey(true); // fails
assert.isPropertyKey({}); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotPropertyKey : the opposite assertion.
- Defined in packages/assert/src/assertions/primitive.ts:30

isString

isString(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is string
Asserts that a value is a string.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is string
Example
```
import {assert} from '@augment-vir/assert';

assert.isString(''); // passes
assert.isString(5); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:233

isSymbol

isSymbol(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is symbol
Asserts that a value is a symbol.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is symbol
Example
```
import {assert} from '@augment-vir/assert';

assert.isSymbol(Symbol('my-symbol')); // passes
assert.isSymbol('my-symbol'); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:260

isTrue

isTrue(
    this: void,
    input: unknown,
    failureMessage?: string,
): asserts input is true
Asserts that a value is exactly true.

Type guards the value.
Parameters
- this: void
- input: unknown
- OptionalfailureMessage: string
Returns asserts input is true
Example
```
import {assert} from '@augment-vir/assert';

assert.isTrue(true); // passes
assert.isTrue(false); // fails
assert.isTrue(1); // fails
assert.isTrue(0); // fails
```
Throws
AssertionError If the value is not true.
See
- assert.isFalse : the opposite assertion.
- assert.isTruthy : a less exact assertion.
- Defined in packages/assert/src/assertions/boolean.ts:141

isTruthy

isTruthy<const Actual>(
    this: void,
    input: Actual,
    failureMessage?: string,
): asserts input is Exclude<Actual, FalsyValue>
Asserts that a value is truthy.

Type guards the value.
Type Parameters
- const Actual
Parameters
- this: void
- input: Actual
- OptionalfailureMessage: string
Returns asserts input is Exclude<Actual, FalsyValue>
Example
```
import {assert} from '@augment-vir/assert';

assert.isTruthy(true); // passes
assert.isTruthy(false); // fails
assert.isTruthy(1); // passes
assert.isTruthy(0); // fails
```
Throws
AssertionError If the value is not truthy.
See
- assert.isFalsy : the opposite assertion.
- assert.isTrue : a more exact assertion.
- Defined in packages/assert/src/assertions/boolean.ts:167

isUndefined

isUndefined(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is undefined
Asserts that a value is exactly undefined.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is undefined
Example
```
import {assert} from '@augment-vir/assert';

assert.isUndefined(undefined); // passes
assert.isUndefined(null); // fails
```
Throws
AssertionError If the assertion failed.
See
- assert.isNotFunction : the opposite assertion.
- Defined in packages/assert/src/assertions/runtime-type.ts:287

isUuid

isUuid(
    this: void,
    actual: unknown,
    failureMessage?: string,
): asserts actual is `${string}-${string}-${string}-${string}-${string}`
Asserts that a value is a valid UUID. Does not accept the nil or max UUIDs.

Type guards the value.
Parameters
- this: void
- actual: unknown
- OptionalfailureMessage: string
Returns asserts actual is `${string}-${string}-${string}-${string}-${string}`
Example
```
import {assert} from '@augment-vir/assert';
import {createUuidV4} from '@augment-vir/common';

assert.isUuid(createUuidV4()); // passes
assert.isUuid('29e0f18e-6115-4982-8342-0afcadf5d611'); // passes
assert.isUuid('00000000-0000-0000-0000-000000000000'); // fails
assert.isUuid('FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF'); // fails
assert.isUuid('not-a-uuid'); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.isNotUuid : the opposite assertion.
- Defined in packages/assert/src/assertions/uuid.ts:31

jsonEquals

jsonEquals<const Actual, const Expected>(
    this: void,
    actual: Actual,
    expected: Expected,
    failureMessage?: string,
): asserts actual is Expected
Asserts 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.

Type guards the first value.
Type Parameters
- const Actual
- const Expected
Parameters
- this: void
- actual: Actual
- expected: Expected
- OptionalfailureMessage: string
Returns asserts actual is Expected
Example
```
import {assert} from '@augment-vir/assert';

assert.jsonEquals({a: 'a'}, {a: 'a'}); // passes

assert.jsonEquals({a: {b: 'b'}}, {a: {b: 'c'}}); // fails
```
Throws
AssertionError If both inputs are not equal.
See
- assert.notJsonEquals : the opposite assertion.
- assert.entriesEqual : another deep equality assertion.
- assert.deepEquals : the most thorough (but also slow) deep equality assertion.
- Defined in packages/assert/src/assertions/equality/json-equality.ts:112

lacksKey

lacksKey<const Parent, const Key extends PropertyKey>(
    this: void,
    parent: Parent,
    key: Key,
    failureMessage?: string,
): asserts parent is Exclude<Parent, Record<Key, any>>
Asserts that a parent value does not have the key.

Type guards the parent value.
Type Parameters
- const Parent
- const Key extends PropertyKey
Parameters
- this: void
- parent: Parent
- key: Key
- OptionalfailureMessage: string
Returns asserts parent is Exclude<Parent, Record<Key, any>>
Example
```
import {assert} from '@augment-vir/assert';

assert.lacksKey({a: 0, b: 1}, 'a'); // fails
assert.lacksKey({a: 0, b: 1}, 'c'); // passes
```
Throws
AssertionError If the parent has the key.
See
- assert.hasKey : the opposite assertion.
- assert.lacksKeys : the multi-key assertion.
- Defined in packages/assert/src/assertions/keys.ts:165

lacksKeys

lacksKeys<const Parent, const Key extends PropertyKey>(
    this: void,
    parent: Parent,
    keys: readonly Key[],
    failureMessage?: string,
): asserts parent is Exclude<Parent, Partial<Record<Key, any>>>
Asserts that a parent value none of the keys.

Type guards the parent value.
Type Parameters
- const Parent
- const Key extends PropertyKey
Parameters
- this: void
- parent: Parent
- keys: readonly Key[]
- OptionalfailureMessage: string
Returns asserts parent is Exclude<Parent, Partial<Record<Key, any>>>
Example
```
import {assert} from '@augment-vir/assert';

assert.lacksKeys({a: 0, b: 1}, ['b', 'c']); // fails
assert.lacksKeys({a: 0, b: 1}, ['c', 'd']); // passes
```
Throws
AssertionError If the parent has any of the keys.
See
- assert.hasKeys : the opposite assertion.
- assert.lacksKey : the single-key assertion.
- Defined in packages/assert/src/assertions/keys.ts:231

lacksValue

lacksValue(
    this: void,
    parent: string | object,
    value: unknown,
    failureMessage?: string,
): void
Asserts that an object/array parent does not include a child value through reference equality.

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

const child = {a: 'a'};

assert.lacksValue({child}, child); // fails
assert.lacksValue({child: {a: 'a'}}, child); // passes
assert.lacksValue([child], child); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.hasValue : the opposite assertion.
- assert.lacksValues : the multi-value assertion.
- Defined in packages/assert/src/assertions/values.ts:117

lacksValues

lacksValues(
    this: void,
    parent: string | object,
    values: unknown[],
    failureMessage?: string,
): void
Asserts that an object/array parent includes none of the provided child values through reference equality.

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

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

assert.lacksValues({}, [child, child2]); // passes
assert.lacksValues({child, child2}, [child, child2]); // fails
assert.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.lacksValues : the opposite assertion.
- assert.hasValue : the single-value assertion.
- Defined in packages/assert/src/assertions/values.ts:215

looseEquals

looseEquals(
    this: void,
    actual: unknown,
    expected: unknown,
    failureMessage?: string,
): void
Asserts that two values are loosely equal (using ==).

Type guards the first value.
Parameters
- this: void
- actual: unknown
- expected: unknown
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.looseEquals('a', 'a'); // passes

assert.looseEquals('1', 1); // passes

assert.looseEquals({a: 'a'}, {a: 'a'}); // fails

const objectExample = {a: 'a'};
assert.looseEquals(objectExample, objectExample); // passes
```
Throws
AssertionError If both inputs are not loosely equal.
See
- assert.notLooseEquals : the opposite assertion.
- assert.strictEquals : the strict equality assertion.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:112

matches

matches(
    this: void,
    actual: string,
    expected: RegExp,
    failureMessage?: string,
): void
Asserts that a string (first input, actual) matches a RegExp (second input, expected).

Performs no type guarding.
Parameters
- this: void
- actual: string
- expected: RegExp
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.matches('hi', /^h/); // passes
assert.matches('hi', /^g/); // fails
```
Throws
AssertionError If the assertion fails.
See
- assert.mismatches : the opposite assertion.
- Defined in packages/assert/src/assertions/regexp.ts:25

mismatches

mismatches(
    this: void,
    actual: string,
    expected: RegExp,
    failureMessage?: string,
): void
Asserts that a string (first input, actual) does not match a RegExp (second input, expected).

Performs no type guarding.
Parameters
- this: void
- actual: string
- expected: RegExp
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.mismatches('hi', /^h/); // fails
assert.mismatches('hi', /^g/); // passes
```
Throws
AssertionError If the assertion fails.
See
- assert.matches : the opposite assertion.
- Defined in packages/assert/src/assertions/regexp.ts:49

notDeepEquals

notDeepEquals(
    this: void,
    actual: unknown,
    expected: unknown,
    failureMessage?: string,
): void
Asserts that two values are not deeply equal using the deep-eql package.

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.
Parameters
- this: void
- actual: unknown
- expected: unknown
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.notDeepEquals('a', 'a'); // false

assert.notDeepEquals('1', 1); // passes

assert.notDeepEquals({a: 'a'}, {a: 'a'}); // fails

const objectExample = {a: 'a'};
assert.notDeepEquals(objectExample, objectExample); // fails
```
Throws
AssertionError If both inputs are deeply equal.
See
- assert.deepEquals : the opposite assertion.
- assert.notEntriesEqual : a less expensive (but less thorough) deep equality assertion.
- assert.notJsonEquals : a less expensive (but less thorough) deep equality assertion.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:237

notEntriesEqual

notEntriesEqual(
    this: void,
    actual: AnyObject,
    expected: AnyObject,
    failureMessage?: string,
): void
Asserts that two objects are not deeply equal by checking only their top-level values for strict (non-deep, reference, using ===) equality.

Performs no type guarding.
Parameters
- this: void
- actual: AnyObject
- expected: AnyObject
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.notEntriesEqual({a: 'a'}, {a: 'a'}); // fails

assert.notEntriesEqual({a: {b: 'b'}}, {a: {b: 'b'}}); // passes

const bExample = {b: 'b'};
assert.notEntriesEqual({a: bExample}, {a: bExample}); // fails
```
Throws
AssertionError If both inputs are equal.
See
- assert.entriesEqual : the opposite assertion.
- assert.notJsonEquals : another not deep equality assertion.
- assert.notDeepEquals : the most thorough (but also slow) not deep equality assertion.
- Defined in packages/assert/src/assertions/equality/entry-equality.ts:92

notInstanceOf

notInstanceOf<const Actual, const Instance>(
    this: void,
    instance: Actual,
    constructor: Constructor<Instance>,
    failureMessage?: string,
): asserts instance is Exclude<Actual, Instance>
Asserts that a value is not an instance of the given class constructor.

Type guards the value.
Type Parameters
- const Actual
- const Instance
Parameters
- this: void
- instance: Actual
- constructor: Constructor<Instance>
- OptionalfailureMessage: string
Returns asserts instance is Exclude<Actual, Instance>
Example
```
import {assert} from '@augment-vir/assert';

assert.notInstanceOf(/abc/, RegExp); // fails
assert.notInstanceOf('abc', RegExp); // passes
```
Throws
AssertionError If the value is an instance of the given class constructor.
See
- assert.instanceOf : the opposite assertion.
- Defined in packages/assert/src/assertions/instance.ts:60

notJsonEquals

notJsonEquals(
    this: void,
    actual: unknown,
    expected: unknown,
    failureMessage?: string,
): void
Asserts 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.

Performs no type guarding.
Parameters
- this: void
- actual: unknown
- expected: unknown
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.notJsonEquals({a: 'a'}, {a: 'a'}); // fails

assert.notJsonEquals({a: {b: 'b'}}, {a: {b: 'c'}}); // passes
```
Throws
AssertionError If both inputs are not equal.
See
- assert.jsonEquals : the opposite assertion.
- assert.entriesEqual : another deep equality assertion.
- assert.deepEquals : the most thorough (but also slow) deep equality assertion.
- Defined in packages/assert/src/assertions/equality/json-equality.ts:147

notLooseEquals

notLooseEquals(
    this: void,
    actual: unknown,
    expected: unknown,
    failureMessage?: string,
): void
Asserts that two values are not loosely equal (using ==).

Performs no type guarding.
Parameters
- this: void
- actual: unknown
- expected: unknown
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.notLooseEquals('a', 'a'); // fails

assert.notLooseEquals('1', 1); // fails

assert.notLooseEquals({a: 'a'}, {a: 'a'}); // passes

const objectExample = {a: 'a'};
assert.notLooseEquals(objectExample, objectExample); // fails
```
Throws
AssertionError If both inputs are loosely equal.
See
- assert.looseEquals : the opposite assertion.
- assert.strictEquals : the strict equality assertion.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:151

notStrictEquals

notStrictEquals(
    this: void,
    actual: unknown,
    expected: unknown,
    failureMessage?: string,
): void
Asserts that two values are not strictly equal (using ===).

Performs no type guarding.
Parameters
- this: void
- actual: unknown
- expected: unknown
- OptionalfailureMessage: string
Returns void
Example
```
import {assert} from '@augment-vir/assert';

assert.notStrictEquals('a', 'a'); // fails

assert.notStrictEquals('1', 1); // passes

assert.notStrictEquals({a: 'a'}, {a: 'a'}); // passes

const objectExample = {a: 'a'};
assert.notStrictEquals(objectExample, objectExample); // fails
```
Throws
AssertionError If both inputs are strictly equal.
See
- assert.strictEquals : the opposite assertion.
- assert.notLooseEquals : the loose equality assertion.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:73

strictEquals

strictEquals<const Actual, const Expected>(
    this: void,
    actual: Actual,
    expected: Expected,
    failureMessage?: string,
): asserts actual is Expected
Asserts that two values are strictly equal (using ===).

Type guards the first value.
Type Parameters
- const Actual
- const Expected
Parameters
- this: void
- actual: Actual
- expected: Expected
- OptionalfailureMessage: string
Returns asserts actual is Expected
Example
```
import {assert} from '@augment-vir/assert';

assert.strictEquals('a', 'a'); // passes

assert.strictEquals('1', 1); // fails

assert.strictEquals({a: 'a'}, {a: 'a'}); // fails

const objectExample = {a: 'a'};
assert.strictEquals(objectExample, objectExample); // passes
```
Throws
AssertionError If both inputs are not strictly equal.
See
- assert.notStrictEquals : the opposite assertion.
- assert.looseEquals : the loose equality assertion.
- Defined in packages/assert/src/assertions/equality/simple-equality.ts:34

Function assert

Example

Throws

Package

Parameters

Returns void

Index

Properties

Methods

Properties

endsWith

Example

Throws

See

endsWithout

Example

Throws

See

fail

Example

Throws

isError

Example

Throws

isLengthAtLeast

Example

Throws

See

isLengthExactly

Example

Throws

See

output

Throws

startsWith

Example

Throws

See

startsWithout

Example

Throws

See

throws

Example

Throws

tsType

Type declaration

Type Parameters

Parameters

Returns AssertTypeOf<Actual>

Type Parameters

Returns AssertTypeOf<Actual>

Example

Returns

Throws

Methods

deepEquals

Type Parameters

Parameters

Returns asserts actual is NarrowToExpected<Actual, Expected>

Example

Throws

See

entriesEqual

Type Parameters

Parameters

Returns asserts actual is Expected

Example

Throws

See

hasKey

Type Parameters

Parameters

Returns asserts parent is CombineTypeWithKey<Key, Parent>

Example

Throws

See

hasKeys

Type Parameters

Parameters