@types/chai

  • Version 4.2.18
  • Published
  • 79.7 kB
  • No dependencies
  • MIT license

Install

npm i @types/chai
yarn add @types/chai
pnpm add @types/chai

Overview

TypeScript definitions for chai

Index

Variables

variable chai

const chai: Chai.ChaiStatic;

    Namespaces

    namespace chai

    module 'chai' {}

      variable chai

      const chai: Chai.ChaiStatic;

        namespace Chai

        namespace 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 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 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 does not 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 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;
                        • Asserts that actual is deeply strict 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 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 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, message?: string): void;
                        (fn: () => void, regExp: RegExp): void;
                        (fn: () => void, constructor: ErrorConstructor, message?: string): void;
                        (fn: () => void, constructor: ErrorConstructor, regExp: RegExp): void;
                        };
                        • Asserts that fn will not throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter regExp

                          Potential expected message match.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor and an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          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) => void;
                        • 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 instanceOf

                        instanceOf: <T>(value: T, constructor: Function, message?: string) => void;
                        • Asserts that value is an instance of constructor.

                          T 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) => void;
                        • 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: <T>(value: T, message?: string) => void;
                        • Asserts that value is false.

                          T Type of value.

                          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) => void;
                        • Asserts that value is not false.

                          T Type of value.

                          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) => void;
                        • 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) => void;
                        • Asserts that value is not true.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNull

                        isNull: <T>(value: T, message?: string) => void;
                        • Asserts that value is null.

                          T Type of value.

                          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: <T>(value: T, message?: string) => void;
                        • Asserts that object is truthy.

                          T Type of object.

                          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: <T>(value: T, message?: string) => void;
                        • Asserts that value is true.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isUndefined

                        isUndefined: <T>(value: T, message?: string) => void;
                        • Asserts that value is undefined.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method lengthOf

                        lengthOf: <T extends { readonly length?: number }>(
                        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 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#notInclude instead.

                        • Asserts that haystack does not 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 does not 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 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: <T>(value: T, message?: string) => void;
                        • Asserts that the target is either null or undefined.

                          T Type of value.

                          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 includes needle.

                          Parameter haystack

                          Container string.

                          Parameter needle

                          Potential substring of haystack.

                          Parameter message

                          Message to display on error.

                        • Asserts that haystack does not 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 does not 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 does not 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 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 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>(value: T, type: Function, message?: string) => void;
                        • Asserts that value is not an instance of constructor.

                          T Type of value.

                          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 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 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 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: <T>(value: T, message?: string) => void;
                        • Asserts that object is truthy.

                          T Type of object.

                          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, message?: string): void;
                        (fn: () => void, regExp: RegExp): void;
                        (fn: () => void, constructor: ErrorConstructor, message?: string): void;
                        (fn: () => void, constructor: ErrorConstructor, regExp: RegExp): void;
                        };
                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter regExp

                          Potential expected message match.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor and an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          Parameter message

                          Message to display on error.

                        method Throw

                        Throw: {
                        (fn: () => void, message?: string): void;
                        (fn: () => void, regExp: RegExp): void;
                        (fn: () => void, constructor: ErrorConstructor, message?: string): void;
                        (fn: () => void, constructor: ErrorConstructor, regExp: RegExp): void;
                        };
                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter regExp

                          Potential expected message match.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor and an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          Parameter message

                          Message to display on error.

                        method throws

                        throws: {
                        (fn: () => void, message?: string): void;
                        (fn: () => void, errType: RegExp | ErrorConstructor, message?: string): void;
                        (fn: () => void, constructor: ErrorConstructor, regExp: RegExp): void;
                        };
                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter errType

                          Potential expected message match or error constructor.

                          Parameter message

                          Message to display on error.

                        • Asserts that function will throw an error that is an instance of constructor and an error with message matching regexp.

                          Parameter fn

                          Function that may throw.

                          Parameter constructor

                          Potential expected error constructor.

                          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): void;
                        • 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) => 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 {}

                                                                                                                                                                                                      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: () => 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 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 Deep

                                                                                                                                                                                                                                                                        interface Deep extends KeyFilter {}

                                                                                                                                                                                                                                                                          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 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: ReadonlyArray<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: ReadonlyArray<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: ReadonlyArray<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 = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // 'expression to be tested'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // This parameter is unused and the docs list its type as
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // 'Philosophical', which is mentioned nowhere else in the source. Do
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // with that what you will!
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Message, // message if value fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Message, // message if negated value fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        any, // expected value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        any?, // actual value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        boolean? // showDiff
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To add a badge like this onejsDocs.io badgeto 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>