@types/chai

Version 5.0.1
Published 1 month ago
90.5 kB
1 dependency
MIT license

Install

npm i @types/chai

yarn add @types/chai

pnpm add @types/chai

Overview

TypeScript definitions for chai

Variables

variable assert

const assert: Chai.AssertStatic;

variable Assertion

const Assertion: Chai.AssertionStatic;

variable config

const config: Chai.Config;

variable expect

const expect: Chai.ExpectStatic;

variable util

const util: Chai.ChaiUtils;

Functions

function should

should: () => Chai.Should;

function Should

Should: () => Chai.Should;

function use

use: (fn: Chai.ChaiPlugin) => Chai.ChaiStatic;

Namespaces

namespace global

namespace global {}

interface Object

interface Object {}

property should

should: Chai.Assertion;

namespace global.Chai

namespace global.Chai {}

class AssertionError

class AssertionError {}

constructor

constructor(message: string, _props?: any, ssf?: Function);

property message

message: string;

property name

name: string;

property showDiff

showDiff: boolean;

property stack

stack: string;

interface Assert

interface Assert {}

method approximately

approximately: (
    act: number,
    exp: number,
    delta: number,
    message?: string
) => void;

Asserts that the target is equal to expected, to within a +/- delta range.
Parameter actual
Actual value
Parameter expected
Potential expected value.
Parameter delta
Maximum differenced between values.
Parameter message
Message to display on error.

method changes

changes: <T>(
    modifier: Function,
    object: T,
    property: string,
    message?: string
) => void;

Asserts that a function changes the value of a property.
T Type of object.
Parameter modifier
Function to run.
Parameter object
Container object.
Parameter property
Property of object expected to be modified.
Parameter message
Message to display on error.

method changesBy

changesBy: {
    <T>(
        modifier: Function,
        object: T,
        property: string,
        change: number,
        message?: string
    ): void;
    <T>(modifier: Function, object: T, change: number, message?: string): void;
};

Asserts that a function changes the value of a property by an amount (delta).
Parameter modifier
function
Parameter object
or getter function
Parameter property
name _optional_
Parameter change
amount (delta)
Parameter message
_optional_

method closeTo

closeTo: (
    actual: number,
    expected: number,
    delta: number,
    message?: string
) => void;

Asserts that the target is equal to expected, to within a +/- delta range.
Parameter actual
Actual value
Parameter expected
Potential expected value.
Parameter delta
Maximum differenced between values.
Parameter message
Message to display on error.

method containsAllDeepKeys

containsAllDeepKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object contains all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method containsAllKeys

containsAllKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object has all of the keys provided but may have more keys not listed. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method decreases

decreases: <T>(
    modifier: Function,
    object: T,
    property: string,
    message?: string
) => void;

Asserts that a function decreases an object property.
T Type of object.
Parameter modifier
Function to run.
Parameter object
Container object.
Parameter property
Property of object expected to be decreased.
Parameter message
Message to display on error.

method decreasesButNotBy

decreasesButNotBy: {
    <T>(
        modifier: Function,
        object: T,
        property: string,
        change: number,
        message?: string
    ): void;
    <T>(modifier: Function, object: T, change: number, message?: string): void;
};

Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta)
T Type of object or function.
Parameter modifier
function
Parameter object
or getter function
Parameter property
name _optional_
Parameter change
amount (delta)
Parameter message
_optional_

method decreasesBy

decreasesBy: {
    <T>(
        modifier: Function,
        object: T,
        property: string,
        change: number,
        message?: string
    ): void;
    <T>(modifier: Function, object: T, change: number, message?: string): void;
};

Asserts that a function decreases a numeric object property or a function's return value by an amount (delta)
T Type of object or function.
Parameter modifier
function
Parameter object
or getter function
Parameter property
name _optional_
Parameter change
amount (delta)
Parameter message
_optional_

method deepEqual

deepEqual: <T>(actual: T, expected: T, message?: string) => void;

Asserts that actual is deeply equal to expected.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method deepInclude

deepInclude: {
    (haystack: string, needle: string, message?: string): void;
    <T>(
        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
        needle: T,
        message?: string
    ): void;
    <T>(
        haystack: T,
        needle: T extends WeakSet<any> ? never : Partial<T>,
        message?: string
    ): void;
};

Asserts that haystack includes needle. Deep equality is used.
Parameter haystack
Container string.
Parameter needle
Potential substring of haystack.
Parameter message
Message to display on error.
Deprecated
Does not have any effect on string. Use Assert#include instead.
Asserts that haystack includes needle. Deep equality is used.
T Type of values in haystack.
Parameter haystack
Container array, set or map.
Parameter needle
Potential value contained in haystack.
Parameter message
Message to display on error.
Asserts that haystack includes needle. Deep equality is used.
T Type of haystack.
Parameter haystack
Object.
Parameter needle
Potential subset of the haystack's properties.
Parameter message
Message to display on error.

method deepNestedInclude

deepNestedInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while checking for deep equality
Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method deepNestedPropertyVal

deepNestedPropertyVal: <T>(
    object: T,
    property: string,
    value: any,
    message?: string
) => void;

Asserts that object has a property named by property with a value given by value. property can use dot- and bracket-notation for nested reference. Uses a deep equality check.
T Type of object.
Parameter object
Object to test.
Parameter property
Property to test.
Parameter value
Value to test.
Parameter message
Message to display on error.

method deepOwnInclude

deepOwnInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties and checking for deep
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method deepProperty

deepProperty: <T>(object: T, property: string, message?: string) => void;

Asserts that object has a property named by property, which can be a string using dot- and bracket-notation for deep reference.
T Type of object.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter message
Message to display on error.

method deepPropertyVal

deepPropertyVal: <T, V>(
    object: T,
    property: string,
    value: V,
    message?: string
) => void;

Asserts that object has a property named by property, which can be a string using dot- and bracket-notation for deep reference.
T Type of object. V Type of value.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter value
Potential expected property value.
Parameter message
Message to display on error.

method deepStrictEqual

deepStrictEqual: <T>(actual: T, expected: T, message?: string) => void;

Alias to deepEqual
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method doesNotChange

doesNotChange: <T>(
    modifier: Function,
    object: T,
    property: string,
    message?: string
) => void;

Asserts that a function does not change the value of a property.
T Type of object.
Parameter modifier
Function to run.
Parameter object
Container object.
Parameter property
Property of object expected not to be modified.
Parameter message
Message to display on error.

method doesNotDecrease

doesNotDecrease: <T>(
    modifier: Function,
    object: T,
    property: string,
    message?: string
) => void;

Asserts that a function does not decrease an object property.
T Type of object.
Parameter modifier
Function to run.
Parameter object
Container object.
Parameter property
Property of object expected not to be decreased.
Parameter message
Message to display on error.

method doesNotDecreaseBy

doesNotDecreaseBy: {
    <T>(
        modifier: Function,
        object: T,
        property: string,
        change: number,
        message?: string
    ): void;
    <T>(modifier: Function, object: T, change: number, message?: string): void;
};

Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta)
T Type of object or function.
Parameter modifier
function
Parameter object
or getter function
Parameter property
name _optional_
Parameter change
amount (delta)
Parameter message
_optional_

method doesNotHaveAllDeepKeys

doesNotHaveAllDeepKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object contains all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method doesNotHaveAllKeys

doesNotHaveAllKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object does not have at least one of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method doesNotHaveAnyDeepKeys

doesNotHaveAnyDeepKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object contains all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method doesNotHaveAnyKeys

doesNotHaveAnyKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object has none of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method doesNotIncrease

doesNotIncrease: <T>(
    modifier: Function,
    object: T,
    property: string,
    message?: string
) => void;

Asserts that a function does not increase an object property.
T Type of object.
Parameter modifier
Function to run.
Parameter object
Container object.
Parameter property
Property of object expected not to be increased.
Parameter message
Message to display on error.

method doesNotThrow

doesNotThrow: {
    (
        fn: () => void,
        errMsgMatcher?: RegExp | string,
        ignored?: any,
        message?: string
    ): void;
    (
        fn: () => void,
        errorLike?: Error | ErrorConstructor,
        errMsgMatcher?: string | RegExp,
        message?: string
    ): void;
};

Asserts that fn will not throw an error.
Parameter fn
Function that may throw.
Parameter errMsgMatcher
Expected error message matcher.
Parameter ignored
Ignored parameter.
Parameter message
Message to display on error.
Asserts that fn will not throw an error.
Parameter fn
Function that may throw.
Parameter errorLike
Expected error constructor or error instance.
Parameter errMsgMatcher
Expected error message matcher.
Parameter message
Message to display on error.

method equal

equal: <T>(actual: T, expected: T, message?: string) => void;

Asserts non-strict equality (==) of actual and expected.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method exists

exists: <T>(value: T, message?: string) => asserts value is NonNullable<T>;

Asserts that the target is neither null nor undefined.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method extensible

extensible: <T>(object: T, message?: string) => void;

Asserts that object is extensible (can have new properties added to it).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method fail

fail: {
    (message?: string): never;
    <T>(actual: T, expected: T, message?: string, operator?: string): never;
};

Throws a failure.
Parameter message
Message to display on error.
Remarks
Node.js assert module-compatible.
Throws a failure.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.
Parameter operator
Comparison operator, if not strict equality.
Remarks
Node.js assert module-compatible.

method frozen

frozen: <T>(object: T, message?: string) => void;

Asserts that object is frozen (cannot have new properties added to it and its existing properties cannot be removed).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method hasAllDeepKeys

hasAllDeepKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object has all and only all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method hasAllKeys

hasAllKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object has all and only all of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method hasAnyDeepKeys

hasAnyDeepKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object has at least one of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method hasAnyKeys

hasAnyKeys: <T>(
    object: T,
    keys: (string | Object)[] | { [key: string]: any },
    message?: string
) => void;

Asserts that object has at least one of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.
T Type of object.
Parameter object
Object to test.
Parameter keys
Keys to check
Parameter message
Message to display on error.

method ifError

ifError: <T>(object: T, message?: string) => void;

Asserts if value is not a false value, and throws if it is a true value.
T Type of object.
Parameter object
Actual value.
Parameter message
Message to display on error.
Remarks
This is added to allow for chai to be a drop-in replacement for Node’s assert class.

method include

include: {
    (haystack: string, needle: string, message?: string): void;
    <T>(
        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
        needle: T,
        message?: string
    ): void;
    <T extends object>(haystack: WeakSet<T>, needle: T, message?: string): void;
    <T>(haystack: T, needle: Partial<T>, message?: string): void;
};

Asserts that haystack includes needle.
Parameter haystack
Container string.
Parameter needle
Potential substring of haystack.
Parameter message
Message to display on error.
Asserts that haystack includes needle.
T Type of values in haystack.
Parameter haystack
Container array, set or map.
Parameter needle
Potential value contained in haystack.
Parameter message
Message to display on error.
Asserts that haystack includes needle.
T Type of values in haystack.
Parameter haystack
WeakSet container.
Parameter needle
Potential value contained in haystack.
Parameter message
Message to display on error.
Asserts that haystack includes needle.
T Type of haystack.
Parameter haystack
Object.
Parameter needle
Potential subset of the haystack's properties.
Parameter message
Message to display on error.

method includeDeepMembers

includeDeepMembers: <T>(superset: T[], subset: T[], message?: string) => void;

Asserts that subset is included in superset using deep equality checking. Order is not take into account.
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method includeDeepOrderedMembers

includeDeepOrderedMembers: <T>(
    superset: T[],
    subset: T[],
    message?: string
) => void;

Asserts that subset is included in superset in the same order beginning with the first element in superset. Uses a deep equality check.
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method includeMembers

includeMembers: <T>(superset: T[], subset: T[], message?: string) => void;

Asserts that subset is included in superset. Order is not take into account.
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method includeOrderedMembers

includeOrderedMembers: <T>(superset: T[], subset: T[], message?: string) => void;

Asserts that subset is included in superset in the same order beginning with the first element in superset. Uses a strict equality check (===).
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method increases

increases: <T>(
    modifier: Function,
    object: T,
    property: string,
    message?: string
) => void;

Asserts that a function increases an object property.
T Type of object.
Parameter modifier
Function to run.
Parameter object
Container object.
Parameter property
Property of object expected to be increased.
Parameter message
Message to display on error.

method increasesButNotBy

increasesButNotBy: {
    <T>(
        modifier: Function,
        object: T,
        property: string,
        change: number,
        message?: string
    ): void;
    <T>(modifier: Function, object: T, change: number, message?: string): void;
};

Asserts that a function does not increase a numeric object property or function's return value by an amount (delta).
T Type of object or function.
Parameter modifier
function
Parameter object
or getter function
Parameter property
name _optional_
Parameter change
amount (delta)
Parameter message
_optional_

method increasesBy

increasesBy: {
    <T>(
        modifier: Function,
        object: T,
        property: string,
        change: number,
        message?: string
    ): void;
    <T>(modifier: Function, object: T, change: number, message?: string): void;
};

Asserts that a function increases a numeric object property or a function's return value by an amount (delta).
T Type of object or function.
Parameter modifier
function
Parameter object
or getter function
Parameter property
name _optional_
Parameter change
amount (delta)
Parameter message
_optional_

method instanceOf

instanceOf: <T>(
    value: unknown,
    constructor: Constructor<T>,
    message?: string
) => asserts value is T;

Asserts that value is an instance of constructor.
T Expected type of value.
Parameter value
Actual value.
Parameter constructor
Potential expected contructor of value.
Parameter message
Message to display on error.

method isAbove

isAbove: (
    valueToCheck: number,
    valueToBeAbove: number,
    message?: string
) => void;

Asserts valueToCheck is strictly greater than (>) valueToBeAbove.
Parameter valueToCheck
Actual value.
Parameter valueToBeAbove
Minimum Potential expected value.
Parameter message
Message to display on error.

method isArray

isArray: <T>(value: T, message?: string) => void;

Asserts that value is an array.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isAtLeast

isAtLeast: (
    valueToCheck: number,
    valueToBeAtLeast: number,
    message?: string
) => void;

Asserts valueToCheck is greater than or equal to (>=) valueToBeAtLeast.
Parameter valueToCheck
Actual value.
Parameter valueToBeAtLeast
Minimum Potential expected value.
Parameter message
Message to display on error.

method isAtMost

isAtMost: (
    valueToCheck: number,
    valueToBeAtMost: number,
    message?: string
) => void;

Asserts valueToCheck is less than or equal to (<=) valueToBeAtMost.
Parameter valueToCheck
Actual value.
Parameter valueToBeAtMost
Minimum Potential expected value.
Parameter message
Message to display on error.

method isBelow

isBelow: (
    valueToCheck: number,
    valueToBeBelow: number,
    message?: string
) => void;

Asserts valueToCheck is strictly less than (<) valueToBeBelow.
Parameter valueToCheck
Actual value.
Parameter valueToBeBelow
Minimum Potential expected value.
Parameter message
Message to display on error.

method isBoolean

isBoolean: <T>(value: T, message?: string) => void;

Asserts that value is a boolean.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isDefined

isDefined: <T>(
    value: T,
    message?: string
) => asserts value is Exclude<T, undefined>;

Asserts that value is not undefined.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isEmpty

isEmpty: <T>(object: T, message?: string) => void;

Asserts that the target does not contain any values. For arrays and strings, it checks the length property. For Map and Set instances, it checks the size property. For non-function objects, it gets the count of own enumerable string keys.
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isExtensible

isExtensible: <T>(object: T, message?: string) => void;

Asserts that object is extensible (can have new properties added to it).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isFalse

isFalse: (value: unknown, message?: string) => asserts value is false;

Asserts that value is false.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isFinite

isFinite: <T>(value: T, message?: string) => void;

Asserts that value is a finite number. Unlike .isNumber, this will fail for NaN and Infinity.
T Type of value
Parameter value
Actual value
Parameter message
Message to display on error.

method isFrozen

isFrozen: <T>(object: T, message?: string) => void;

Asserts that object is frozen (cannot have new properties added to it and its existing properties cannot be removed).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isFunction

isFunction: <T>(value: T, message?: string) => void;

Asserts that value is a function.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNaN

isNaN: <T>(value: T, message?: string) => void;

Asserts that value is NaN.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotArray

isNotArray: <T>(value: T, message?: string) => void;

Asserts that value is not an array.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotBoolean

isNotBoolean: <T>(value: T, message?: string) => void;

Asserts that value is not a boolean.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotEmpty

isNotEmpty: <T>(object: T, message?: string) => void;

Asserts that the target contains values. For arrays and strings, it checks the length property. For Map and Set instances, it checks the size property. For non-function objects, it gets the count of own enumerable string keys.
T Type of object.
Parameter object
Object to test.
Parameter message
Message to display on error.

method isNotExtensible

isNotExtensible: <T>(object: T, message?: string) => void;

Asserts that object is not extensible.
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isNotFalse

isNotFalse: <T>(
    value: T,
    message?: string
) => asserts value is Exclude<T, false>;

Asserts that value is not false.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotFrozen

isNotFrozen: <T>(object: T, message?: string) => void;

Asserts that object is not frozen (cannot have new properties added to it and its existing properties cannot be removed).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isNotFunction

isNotFunction: <T>(value: T, message?: string) => void;

Asserts that value is not a function.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotNaN

isNotNaN: <T>(value: T, message?: string) => void;

Asserts that value is not NaN.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotNull

isNotNull: <T>(value: T, message?: string) => asserts value is Exclude<T, null>;

Asserts that value is not null.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotNumber

isNotNumber: <T>(value: T, message?: string) => void;

Asserts that value is not a number.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotObject

isNotObject: <T>(value: T, message?: string) => void;

Asserts that value is not an object of type 'Object' (as revealed by Object.prototype.toString).
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotOk

isNotOk: <T>(value: T, message?: string) => void;

Asserts that object is falsy.
T Type of object.
Parameter object
Object to test.
Parameter message
Message to display on error.

method isNotSealed

isNotSealed: <T>(object: T, message?: string) => void;

Asserts that object is not sealed.
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isNotString

isNotString: <T>(value: T, message?: string) => void;

Asserts that value is not a string.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNotTrue

isNotTrue: <T>(value: T, message?: string) => asserts value is Exclude<T, true>;

Asserts that value is not true.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNull

isNull: (value: unknown, message?: string) => asserts value is null;

Asserts that value is null.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isNumber

isNumber: <T>(value: T, message?: string) => void;

Asserts that value is a number.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isObject

isObject: <T>(value: T, message?: string) => void;

Asserts that value is an object of type 'Object' (as revealed by Object.prototype.toString).
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.
Remarks
The assertion does not match subclassed objects.

method isOk

isOk: (value: unknown, message?: string) => asserts value;

Asserts that object is truthy.
Parameter object
Object to test.
Parameter message
Message to display on error.

method isSealed

isSealed: <T>(object: T, message?: string) => void;

Asserts that object is sealed (can have new properties added to it and its existing properties cannot be removed).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method isString

isString: <T>(value: T, message?: string) => void;

Asserts that value is a string.
T Type of value.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isTrue

isTrue: (value: unknown, message?: string) => asserts value is true;

Asserts that value is true.
Parameter value
Actual value.
Parameter message
Message to display on error.

method isUndefined

isUndefined: (value: unknown, message?: string) => asserts value is undefined;

Asserts that value is undefined.
Parameter value
Actual value.
Parameter message
Message to display on error.

method lengthOf

lengthOf: <
    T extends
        | { readonly length?: number | undefined }
        | { readonly size?: number | undefined }
>(
    object: T,
    length: number,
    message?: string
) => void;

Asserts that object has a length property with the expected value.
T Type of object.
Parameter object
Container object.
Parameter length
Potential expected length of object.
Parameter message
Message to display on error.

method match

match: (value: string, regexp: RegExp, message?: string) => void;

Asserts that value matches the regular expression regexp.
Parameter value
Actual value.
Parameter regexp
Potential match of value.
Parameter message
Message to display on error.

method nestedInclude

nestedInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object.
Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method nestedProperty

nestedProperty: <T>(object: T, property: string, message?: string) => void;

Asserts that object has a direct or inherited property named by property, which can be a string using dot- and bracket-notation for nested reference.
T Type of object.
Parameter object
Object to test.
Parameter property
Property to test.
Parameter message
Message to display on error.

method nestedPropertyVal

nestedPropertyVal: <T>(
    object: T,
    property: string,
    value: any,
    message?: string
) => void;

Asserts that object has a property named by property with value given by value. property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).
T Type of object.
Parameter object
Object to test.
Parameter property
Property to test.
Parameter value
Value to test.
Parameter message
Message to display on error.

method notDeepEqual

notDeepEqual: <T>(actual: T, expected: T, message?: string) => void;

Asserts that actual is not deeply equal to expected.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method notDeepInclude

notDeepInclude: {
    (haystack: string, needle: string, message?: string): void;
    <T>(
        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
        needle: T,
        message?: string
    ): void;
    <T>(
        haystack: T,
        needle: T extends WeakSet<any> ? never : Partial<T>,
        message?: string
    ): void;
};

Asserts that haystack does not include needle. Deep equality is used.
Parameter haystack
Container string.
Parameter needle
Potential substring of haystack.
Parameter message
Message to display on error.
Deprecated
Does not have any effect on string. Use Assert#notInclude instead.
Asserts that haystack does not include needle. Deep equality is used.
T Type of values in haystack.
Parameter haystack
Container array, set or map.
Parameter needle
Potential value contained in haystack.
Parameter message
Message to display on error.
Asserts that haystack does not include needle. Deep equality is used.
T Type of haystack.
Parameter haystack
Object.
Parameter needle
Potential subset of the haystack's properties.
Parameter message
Message to display on error.

method notDeepNestedInclude

notDeepNestedInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object while checking for deep equality.
Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method notDeepNestedPropertyVal

notDeepNestedPropertyVal: <T>(
    object: T,
    property: string,
    value: any,
    message?: string
) => void;

Asserts that object does not have a property named by property with value given by value. property can use dot- and bracket-notation for nested reference. Uses a deep equality check.
T Type of object.
Parameter object
Object to test.
Parameter property
Property to test.
Parameter value
Value to test.
Parameter message
Message to display on error.

method notDeepOwnInclude

notDeepOwnInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties and checking for deep equality.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method notDeepProperty

notDeepProperty: <T>(object: T, property: string, message?: string) => void;

Asserts that object does not have a property named by property, which can be a string using dot- and bracket-notation for deep reference.
T Type of object.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter message
Message to display on error.

method notDeepPropertyVal

notDeepPropertyVal: <T, V>(
    object: T,
    property: string,
    value: V,
    message?: string
) => void;

Asserts that object does not have a property named by property, which can be a string using dot- and bracket-notation for deep reference.
T Type of object. V Type of value.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter value
Potential expected property value.
Parameter message
Message to display on error.

method notEqual

notEqual: <T>(actual: T, expected: T, message?: string) => void;

Asserts non-strict inequality (!=) of actual and expected.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method notExists

notExists: (value: unknown, message?: string) => asserts value is null;

Asserts that the target is either null or undefined.
Parameter value
Actual value.
Parameter message
Message to display on error.

method notExtensible

notExtensible: <T>(object: T, message?: string) => void;

Asserts that object is not extensible.
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method notFrozen

notFrozen: <T>(object: T, message?: string) => void;

Asserts that object is not frozen (cannot have new properties added to it and its existing properties cannot be removed).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method notInclude

notInclude: {
    (haystack: string, needle: string, message?: string): void;
    <T>(
        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
        needle: T,
        message?: string
    ): void;
    <T extends object>(haystack: WeakSet<T>, needle: T, message?: string): void;
    <T>(haystack: T, needle: Partial<T>, message?: string): void;
};

Asserts that haystack does not include needle.
Parameter haystack
Container string.
Parameter needle
Potential substring of haystack.
Parameter message
Message to display on error.
Asserts that haystack does not include needle.
T Type of values in haystack.
Parameter haystack
Container array, set or map.
Parameter needle
Potential value contained in haystack.
Parameter message
Message to display on error.
Asserts that haystack does not include needle.
T Type of values in haystack.
Parameter haystack
WeakSet container.
Parameter needle
Potential value contained in haystack.
Parameter message
Message to display on error.
Asserts that haystack does not include needle.
T Type of haystack.
Parameter haystack
Object.
Parameter needle
Potential subset of the haystack's properties.
Parameter message
Message to display on error.

method notIncludeDeepMembers

notIncludeDeepMembers: <T>(superset: T[], subset: T[], message?: string) => void;

Asserts that subset isn't included in superset in any order. Uses a deep equality check. Duplicates are ignored.
assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method notIncludeDeepOrderedMembers

notIncludeDeepOrderedMembers: <T>(
    superset: T[],
    subset: T[],
    message?: string
) => void;

Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. Uses a deep equality check.
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method notIncludeMembers

notIncludeMembers: <T>(superset: T[], subset: T[], message?: string) => void;

Asserts that subset isn’t included in superset in any order. Uses a strict equality check (===). Duplicates are ignored.
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential not contained set of values.
Parameter message
Message to display on error.

method notIncludeOrderedMembers

notIncludeOrderedMembers: <T>(
    superset: T[],
    subset: T[],
    message?: string
) => void;

Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. Uses a strict equality check (===).
T Type of set values.
Parameter superset
Actual set of values.
Parameter subset
Potential contained set of values.
Parameter message
Message to display on error.

method notInstanceOf

notInstanceOf: <T, U>(
    value: T,
    type: Constructor<U>,
    message?: string
) => asserts value is Exclude<T, U>;

Asserts that value is not an instance of constructor.
T Type of value. U Type that value shouldn't be an instance of.
Parameter value
Actual value.
Parameter constructor
Potential expected contructor of value.
Parameter message
Message to display on error.

method notMatch

notMatch: (expected: any, regexp: RegExp, message?: string) => void;

Asserts that value does not match the regular expression regexp.
Parameter value
Actual value.
Parameter regexp
Potential match of value.
Parameter message
Message to display on error.

method notNestedInclude

notNestedInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object.
Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. ‘[]’ and ‘.’ in property names can be escaped using double backslashes.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method notNestedProperty

notNestedProperty: <T>(object: T, property: string, message?: string) => void;

Asserts that object does not have a property named by property, which can be a string using dot- and bracket-notation for nested reference. The property cannot exist on the object nor anywhere in its prototype chain.
T Type of object.
Parameter object
Object to test.
Parameter property
Property to test.
Parameter message
Message to display on error.

method notNestedPropertyVal

notNestedPropertyVal: <T>(
    object: T,
    property: string,
    value: any,
    message?: string
) => void;

Asserts that object does not have a property named by property with value given by value. property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).
T Type of object.
Parameter object
Object to test.
Parameter property
Property to test.
Parameter value
Value to test.
Parameter message
Message to display on error.

method notOk

notOk: <T>(value: T, message?: string) => void;

Asserts that object is falsy.
T Type of object.
Parameter object
Object to test.
Parameter message
Message to display on error.

method notOwnInclude

notOwnInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method notProperty

notProperty: <T>(object: T, property: string, message?: string) => void;

Asserts that object does not have a property named by property.
T Type of object.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter message
Message to display on error.

method notPropertyVal

notPropertyVal: <T, V>(
    object: T,
    property: string,
    value: V,
    message?: string
) => void;

Asserts that object has a property named by property with value given by value.
T Type of object. V Type of value.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter value
Potential expected property value.
Parameter message
Message to display on error.

method notSameDeepMembers

notSameDeepMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 don't have the same members in any order. Uses a deep equality check.
T Type of set values.
Parameter set1
Parameter set2
Parameter message

method notSameDeepOrderedMembers

notSameDeepOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 don’t have the same members in the same order. Uses a deep equality check.
T Type of set values.
Parameter set1
Actual set of values.
Parameter set2
Potential expected set of values.
Parameter message
Message to display on error.

method notSameOrderedMembers

notSameOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 don’t have the same members in the same order. Uses a strict equality check (===).
T Type of set values.
Parameter set1
Actual set of values.
Parameter set2
Potential expected set of values.
Parameter message
Message to display on error.

method notSealed

notSealed: <T>(object: T, message?: string) => void;

Asserts that object is not sealed.
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method notStrictEqual

notStrictEqual: <T>(actual: T, expected: T, message?: string) => void;

Asserts strict inequality (!==) of actual and expected.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method notTypeOf

notTypeOf: <T>(value: T, name: string, message?: string) => void;

Asserts that value's type is not name, as determined by Object.prototype.toString.
T Type of value.
Parameter value
Actual value.
Parameter name
Potential expected type name of value.
Parameter message
Message to display on error.

method ok

ok: (value: unknown, message?: string) => asserts value;

Asserts that object is truthy.
Parameter object
Object to test.
Parameter message
Message to display on error.

method oneOf

oneOf: <T>(inList: T, list: T[], message?: string) => void;

Asserts that non-object, non-array value inList appears in the flat array list.
T Type of list values.
Parameter inList
Value expected to be in the list.
Parameter list
List of values.
Parameter message
Message to display on error.

method operator

operator: (
    val1: OperatorComparable,
    operator: Operator,
    val2: OperatorComparable,
    message?: string
) => void;

Compares two values using operator.
Parameter val1
Left value during comparison.
Parameter operator
Comparison operator.
Parameter val2
Right value during comparison.
Parameter message
Message to display on error.

method ownInclude

ownInclude: (haystack: any, needle: any, message?: string) => void;

Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties.
Parameter haystack
Parameter needle
Parameter message
Message to display on error.

method property

property: <T>(object: T, property: string, message?: string) => void;

Asserts that object has a property named by property.
T Type of object.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter message
Message to display on error.

method propertyVal

propertyVal: <T, V>(
    object: T,
    property: string,
    value: V,
    message?: string
) => void;

Asserts that object has a property named by property with value given by value.
T Type of object. V Type of value.
Parameter object
Container object.
Parameter property
Potential contained property of object.
Parameter value
Potential expected property value.
Parameter message
Message to display on error.

method sameDeepMembers

sameDeepMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 have the same members using deep equality checking. Order is not take into account.
T Type of set values.
Parameter set1
Actual set of values.
Parameter set2
Potential expected set of values.
Parameter message
Message to display on error.

method sameDeepOrderedMembers

sameDeepOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 have the same members in the same order. Uses a deep equality check.
T Type of set values.
Parameter set1
Actual set of values.
Parameter set2
Potential expected set of values.
Parameter message
Message to display on error.

method sameMembers

sameMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 have the same members. Order is not take into account.
T Type of set values.
Parameter set1
Actual set of values.
Parameter set2
Potential expected set of values.
Parameter message
Message to display on error.

method sameOrderedMembers

sameOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;

Asserts that set1 and set2 have the same members in the same order. Uses a strict equality check (===).
T Type of set values.
Parameter set1
Actual set of values.
Parameter set2
Potential expected set of values.
Parameter message
Message to display on error.

method sealed

sealed: <T>(object: T, message?: string) => void;

Asserts that object is sealed (can have new properties added to it and its existing properties cannot be removed).
T Type of object
Parameter object
Actual value.
Parameter message
Message to display on error.

method strictEqual

strictEqual: <T>(actual: T, expected: T, message?: string) => void;

Asserts strict equality (===) of actual and expected.
T Type of the objects.
Parameter actual
Actual value.
Parameter expected
Potential expected value.
Parameter message
Message to display on error.

method throw

throw: {
    (
        fn: () => void,
        errMsgMatcher?: RegExp | string,
        ignored?: any,
        message?: string
    ): void;
    (
        fn: () => void,
        errorLike?: Error | ErrorConstructor,
        errMsgMatcher?: string | RegExp,
        message?: string
    ): void;
};

Asserts that fn will throw an error.
Parameter fn
Function that may throw.
Parameter errMsgMatcher
Expected error message matcher.
Parameter ignored
Ignored parameter.
Parameter message
Message to display on error.
Asserts that fn will throw an error.
Parameter fn
Function that may throw.
Parameter errorLike
Expected error constructor or error instance.
Parameter errMsgMatcher
Expected error message matcher.
Parameter message
Message to display on error.

method Throw

Throw: {
    (
        fn: () => void,
        errMsgMatcher?: RegExp | string,
        ignored?: any,
        message?: string
    ): void;
    (
        fn: () => void,
        errorLike?: Error | ErrorConstructor,
        errMsgMatcher?: string | RegExp,
        message?: string
    ): void;
};

Asserts that fn will throw an error.
Parameter fn
Function that may throw.
Parameter errMsgMatcher
Expected error message matcher.
Parameter ignored
Ignored parameter.
Parameter message
Message to display on error.
Asserts that fn will throw an error.
Parameter fn
Function that may throw.
Parameter errorLike
Expected error constructor or error instance.
Parameter errMsgMatcher
Expected error message matcher.
Parameter message
Message to display on error.

method throws

throws: {
    (
        fn: () => void,
        errMsgMatcher?: RegExp | string,
        ignored?: any,
        message?: string
    ): void;
    (
        fn: () => void,
        errorLike?: Error | ErrorConstructor,
        errMsgMatcher?: string | RegExp,
        message?: string
    ): void;
};

Asserts that fn will throw an error.
Parameter fn
Function that may throw.
Parameter errMsgMatcher
Expected error message matcher.
Parameter ignored
Ignored parameter.
Parameter message
Message to display on error.
Asserts that fn will throw an error.
Parameter fn
Function that may throw.
Parameter errorLike
Expected error constructor or error instance.
Parameter errMsgMatcher
Expected error message matcher.
Parameter message
Message to display on error.

method typeOf

typeOf: <T>(value: T, name: string, message?: string) => void;

Asserts that value's type is name, as determined by Object.prototype.toString.
T Type of value.
Parameter value
Actual value.
Parameter name
Potential expected type name of value.
Parameter message
Message to display on error.

call signature

(expression: any, message?: string): asserts expression;

Parameter expression
Expression to test for truthiness.
Parameter message
Message to display on error.

interface Assertion

interface Assertion extends LanguageChains, NumericComparison, TypeComparison {}

property a

a: Assertion;

property all

all: KeyFilter;

property an

an: Assertion;

property any

any: KeyFilter;

property approximately

approximately: CloseTo;

property arguments

arguments: Assertion;

property Arguments

Arguments: Assertion;

property change

change: PropertyChange;

property changes

changes: PropertyChange;

property closeTo

closeTo: CloseTo;

property contain

contain: Include;

property contains

contains: Include;

property decrease

decrease: PropertyChange;

property decreases

decreases: PropertyChange;

property deep

deep: Deep;

property empty

empty: Assertion;

property eq

eq: Equal;

property eql

eql: Equal;

property eqls

eqls: Equal;

property equal

equal: Equal;

property equals

equals: Equal;

property exist

exist: Assertion;

property extensible

extensible: Assertion;

property false

false: Assertion;

property finite

finite: Assertion;

property frozen

frozen: Assertion;

property haveOwnProperty

haveOwnProperty: Property;

property haveOwnPropertyDescriptor

haveOwnPropertyDescriptor: OwnPropertyDescriptor;

property include

include: Include;

property includes

includes: Include;

property increase

increase: PropertyChange;

property increases

increases: PropertyChange;

property itself

itself: Assertion;

property keys

keys: Keys;

property length

length: Length;

property lengthOf

lengthOf: Length;

property match

match: Match;

property matches

matches: Match;

property members

members: Members;

property NaN

NaN: Assertion;

property nested

nested: Nested;

property not

not: Assertion;

property null

null: Assertion;

property ok

ok: Assertion;

property oneOf

oneOf: OneOf;

property ordered

ordered: Ordered;

property own

own: Own;

property ownProperty

ownProperty: Property;

property ownPropertyDescriptor

ownPropertyDescriptor: OwnPropertyDescriptor;

property property

property: Property;

property respondsTo

respondsTo: RespondTo;

property respondTo

respondTo: RespondTo;

property satisfies

satisfies: Satisfy;

property satisfy

satisfy: Satisfy;

property sealed

sealed: Assertion;

property throw

throw: Throw;

property Throw

Throw: Throw;

property throws

throws: Throw;

property true

true: Assertion;

property undefined

undefined: Assertion;

method key

key: (string: string) => Assertion;

method string

string: (string: string, message?: string) => Assertion;

interface AssertionPrototype

interface AssertionPrototype {}

method assert

assert: (
    args_0: any,
    args_1: Message,
    args_2: Message,
    args_3?: any,
    args_4?: any,
    args_5?: boolean
) => void;

interface AssertionStatic

interface AssertionStatic extends AssertionPrototype {}

property includeStack

includeStack: boolean;

property prototype

prototype: AssertionPrototype;

property showDiff

showDiff: boolean;

method addChainableMethod

addChainableMethod: (
    name: string,
    method: (this: AssertionStatic, ...args: any[]) => void,
    chainingBehavior?: () => void
) => void;

method addMethod

addMethod: (
    name: string,
    method: (this: AssertionStatic, ...args: any[]) => any
) => void;

method addProperty

addProperty: (name: string, getter: (this: AssertionStatic) => any) => void;

method overwriteChainableMethod

overwriteChainableMethod: (
    name: string,
    method: (this: AssertionStatic, ...args: any[]) => void,
    chainingBehavior?: () => void
) => void;

method overwriteMethod

overwriteMethod: (
    name: string,
    method: (this: AssertionStatic, ...args: any[]) => any
) => void;

method overwriteProperty

overwriteProperty: (
    name: string,
    getter: (this: AssertionStatic, _super: any) => any
) => void;

construct signature

new (
    target: any,
    message?: string,
    ssfi?: Function,
    lockSsfi?: boolean
): Assertion;

interface AssertStatic

interface AssertStatic extends Assert {}

interface ChaiStatic

interface ChaiStatic {}

property assert

assert: AssertStatic;

property Assertion

Assertion: AssertionStatic;

property AssertionError

AssertionError: typeof AssertionError;

property config

config: Config;

property expect

expect: ExpectStatic;

property util

util: ChaiUtils;

property version

version: string;

method should

should: () => Should;

method use

use: (fn: ChaiPlugin) => ChaiStatic;

Provides a way to extend the internals of Chai

interface ChaiUtils

interface ChaiUtils {}

property eql

eql: typeof deepEqual;

method addChainableMethod

addChainableMethod: (
    ctx: object,
    name: string,
    method: (...args: any[]) => void,
    chainingBehavior?: () => void
) => void;

method addLengthGuard

addLengthGuard: (
    fn: Function,
    assertionName: string,
    isChainable: boolean
) => void;

method addMethod

addMethod: (ctx: object, name: string, method: Function) => void;

method addProperty

addProperty: (ctx: object, name: string, getter: () => any) => void;

method compareByInspect

compareByInspect: (a: object, b: object) => -1 | 1;

method compatibleConstructor

compatibleConstructor: (
    thrown: Error,
    errorLike: Error | ErrorConstructor
) => boolean;

method compatibleInstance

compatibleInstance: (
    thrown: Error,
    errorLike: Error | ErrorConstructor
) => boolean;

method compatibleMessage

compatibleMessage: (thrown: Error, errMatcher: string | RegExp) => boolean;

method expectTypes

expectTypes: (obj: object, types: string[]) => void;

method flag

flag: (obj: object, key: string, value?: any) => any;

method getActual

getActual: (obj: object, args: AssertionArgs) => any;

method getConstructorName

getConstructorName: (constructorFn: Function) => string;

method getEnumerableProperties

getEnumerableProperties: (obj: object) => string[];

method getFuncName

getFuncName: (constructorFn: Function) => string | null;

method getMessage

getMessage: {
    (errorLike: Error | string): string;
    (obj: any, args: AssertionArgs): string;
};

method getOwnEnumerableProperties

getOwnEnumerableProperties: (obj: object) => Array<string | symbol>;

method getOwnEnumerablePropertySymbols

getOwnEnumerablePropertySymbols: (obj: object) => symbol[];

method getPathInfo

getPathInfo: (obj: object, path: string) => PathInfo;

method getPathValue

getPathValue: (obj: object, path: string) => object | undefined;

method getProperties

getProperties: (obj: object) => string[];

method hasProperty

hasProperty: (obj: object | undefined | null, name: ObjectProperty) => boolean;

method inspect

inspect: (
    obj: any,
    showHidden?: boolean,
    depth?: number,
    colors?: boolean
) => string;

method isProxyEnabled

isProxyEnabled: () => boolean;

method objDisplay

objDisplay: (obj: object) => void;

method overwriteChainableMethod

overwriteChainableMethod: (
    ctx: object,
    name: string,
    method: (...args: any[]) => void,
    chainingBehavior?: () => void
) => void;

method overwriteMethod

overwriteMethod: (ctx: object, name: string, method: Function) => void;

method overwriteProperty

overwriteProperty: (
    ctx: object,
    name: string,
    getter: (this: AssertionStatic, _super: any) => any
) => void;

method proxify

proxify: (obj: object, nonChainableMethodName: string) => object;

method test

test: (obj: object, args: AssertionArgs) => boolean;

method transferFlags

transferFlags: (assertion: Assertion, obj: object, includeAll?: boolean) => void;

interface CloseTo

interface CloseTo {}

call signature

(expected: number, delta: number, message?: string): Assertion;

interface Config

interface Config {}

property deepEqual

deepEqual: <L, R>(expected: L, actual: R) => void;

property includeStack

includeStack: boolean;

Default: false

property proxyExcludedKeys

proxyExcludedKeys: string[];

Default: ['then', 'catch', 'inspect', 'toJSON']

property showDiff

showDiff: boolean;

Default: true

property truncateThreshold

truncateThreshold: number;

Default: 40

property useProxy

useProxy: boolean;

Default: true

interface Constructor

interface Constructor<T> {}

construct signature

new (...args: any[]): T;

interface Deep

interface Deep extends KeyFilter {}

property be

be: Assertion;

property contain

contain: Include;

property contains

contains: Include;

property eq

eq: Equal;

property equal

equal: Equal;

property equals

equals: Equal;

property include

include: Include;

property includes

includes: Include;

property nested

nested: Nested;

property oneOf

oneOf: OneOf;

property ordered

ordered: Ordered;

property own

own: Own;

property property

property: Property;

interface DeltaAssertion

interface DeltaAssertion extends Assertion {}

method by

by: (delta: number, msg?: string) => Assertion;

interface Equal

interface Equal {}

call signature

(value: any, message?: string): Assertion;

interface ErrorConstructor

interface ErrorConstructor {}

construct signature

new (...args: any[]): Error;

interface ExpectStatic

interface ExpectStatic {}

method fail

fail: {
    (message?: string): never;
    (actual: any, expected: any, message?: string, operator?: string): never;
};

call signature

(val: any, message?: string): Assertion;

interface Include

interface Include {}

property all

all: KeyFilter;

property any

any: KeyFilter;

property deep

deep: Deep;

property keys

keys: Keys;

property members

members: Members;

property oneOf

oneOf: OneOf;

property ordered

ordered: Ordered;

call signature

(value: any, message?: string): Assertion;

interface InstanceOf

interface InstanceOf {}

call signature

(constructor: any, message?: string): Assertion;

interface KeyFilter

interface KeyFilter {}

property keys

keys: Keys;

property members

members: Members;

interface Keys

interface Keys {}

call signature

(...keys: string[]): Assertion;

call signature

(keys: readonly any[] | Object): Assertion;

interface LanguageChains

interface LanguageChains {}

property and

and: Assertion;

property at

at: Assertion;

property be

be: Assertion;

property been

been: Assertion;

property but

but: Assertion;

property does

does: Assertion;

property has

has: Assertion;

property have

have: Assertion;

property is

is: Assertion;

property of

of: Assertion;

property same

same: Assertion;

property that

that: Assertion;

property to

to: Assertion;

property which

which: Assertion;

property with

with: Assertion;

interface Length

interface Length extends LanguageChains, NumericComparison {}

call signature

(length: number, message?: string): Assertion;

interface Match

interface Match {}

call signature

(regexp: RegExp, message?: string): Assertion;

interface Members

interface Members {}

call signature

(set: readonly any[], message?: string): Assertion;

interface Nested

interface Nested {}

property contain

contain: Include;

property contains

contains: Include;

property include

include: Include;

property includes

includes: Include;

property members

members: Members;

property property

property: Property;

interface NumberComparer

interface NumberComparer {}

call signature

(value: number | Date, message?: string): Assertion;

interface NumericComparison

interface NumericComparison {}

property above

above: NumberComparer;

property below

below: NumberComparer;

property greaterThan

greaterThan: NumberComparer;

property greaterThanOrEqual

greaterThanOrEqual: NumberComparer;

property gt

gt: NumberComparer;

property gte

gte: NumberComparer;

property least

least: NumberComparer;

property lessThan

lessThan: NumberComparer;

property lessThanOrEqual

lessThanOrEqual: NumberComparer;

property lt

lt: NumberComparer;

property lte

lte: NumberComparer;

property most

most: NumberComparer;

method within

within: {
    (start: number, finish: number, message?: string): Assertion;
    (start: Date, finish: Date, message?: string): Assertion;
};

interface OneOf

interface OneOf {}

call signature

(list: readonly unknown[], message?: string): Assertion;

interface Ordered

interface Ordered {}

property members

members: Members;

interface Own

interface Own {}

property contain

contain: Include;

property contains

contains: Include;

property include

include: Include;

property includes

includes: Include;

property property

property: Property;

interface OwnPropertyDescriptor

interface OwnPropertyDescriptor {}

call signature

(
    name: string | symbol,
    descriptor: PropertyDescriptor,
    message?: string
): Assertion;

call signature

(name: string | symbol, message?: string): Assertion;

interface PathInfo

interface PathInfo {}

property exists

exists: boolean;

property name

name: string;

property parent

parent: object;

property value

value?: any;

interface Property

interface Property {}

call signature

(name: string | symbol, value: any, message?: string): Assertion;

call signature

(name: string | symbol, message?: string): Assertion;

interface PropertyChange

interface PropertyChange {}

call signature

(object: Object, property?: string, message?: string): DeltaAssertion;

interface RespondTo

interface RespondTo {}

call signature

(method: string, message?: string): Assertion;

interface Satisfy

interface Satisfy {}

call signature

(matcher: Function, message?: string): Assertion;

interface Should

interface Should extends ShouldAssertion {}

property not

not: ShouldAssertion;

method fail

fail: {
    (message?: string): never;
    (actual: any, expected: any, message?: string, operator?: string): never;
};

interface ShouldAssertion

interface ShouldAssertion {}

property throw

throw: ShouldThrow;

property Throw

Throw: ShouldThrow;

method equal

equal: (value1: any, value2: any, message?: string) => void;

method exist

exist: (value: any, message?: string) => void;

interface ShouldThrow

interface ShouldThrow {}

call signature

(actual: Function, expected?: string | RegExp, message?: string): void;

call signature

(
    actual: Function,
    constructor: Error | Function,
    expected?: string | RegExp,
    message?: string
): void;

interface Throw

interface Throw {}

call signature

(expected?: string | RegExp, message?: string): Assertion;

call signature

(
    constructor: Error | Function,
    expected?: string | RegExp,
    message?: string
): Assertion;

interface TypeComparison

interface TypeComparison {}

property instanceof

instanceof: InstanceOf;

property instanceOf

instanceOf: InstanceOf;

call signature

(type: string, message?: string): Assertion;

type AssertionArgs

type AssertionArgs = [
    any, // expression to be tested
    Message, // message or function that returns message to display if expression fails
    Message, // negatedMessage or function that returns negatedMessage to display if expression fails
    any?, // expected value
    any?, // actual value
    boolean? // showDiff, when set to `true`, assert will display a diff in addition to the message if expression fails
];

type ChaiPlugin

type ChaiPlugin = (chai: ChaiStatic, utils: ChaiUtils) => void;

type Message

type Message = string | (() => string);

type ObjectProperty

type ObjectProperty = string | symbol | number;

type Operator

type Operator = string;

type OperatorComparable

type OperatorComparable = boolean | null | number | string | undefined | Date;

Package Files (1)

index.d.ts

Dependencies (1)

@types/deep-eql

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/chai.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/chai)

HTML

<a href="https://www.jsdocs.io/package/@types/chai"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 7087 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/chai

Install

Overview

Index

Variables

Functions

Namespaces

Variables

variable assert

variable Assertion

variable config

variable expect

variable util

Functions

function should

function Should

function use

Namespaces

namespace global

interface Object

property should

namespace global.Chai

class AssertionError

constructor

property message

property name

property showDiff

property stack

interface Assert

method approximately

Parameter actual

Parameter expected

Parameter delta

Parameter message

method changes

Parameter modifier

Parameter object

Parameter property

Parameter message

method changesBy

Parameter modifier

Parameter object

Parameter property

Parameter change

Parameter message

method closeTo

Parameter actual

Parameter expected

Parameter delta

Parameter message

method containsAllDeepKeys

Parameter object

Parameter keys

Parameter message

method containsAllKeys

Parameter object

Parameter keys

Parameter message

method decreases

Parameter modifier

Parameter object

Parameter property

Parameter message

method decreasesButNotBy

Parameter modifier

Parameter object

Parameter property

Parameter change

Parameter message

method decreasesBy

Parameter modifier

Parameter object

Parameter property

Parameter change

Parameter message

method deepEqual

Parameter actual

Parameter expected

Parameter message

method deepInclude