@types/chai

  • Version 4.3.16
  • Published
  • 82.2 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 changesBy

                        changesBy: {
                        <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        change: number,
                        message?: string
                        ): void;
                        <T>(modifier: Function, object: T, change: number, message?: string): void;
                        };
                        • Asserts that a function changes the value of a property by an amount (delta).

                          Parameter modifier

                          function

                          Parameter object

                          or getter function

                          Parameter property

                          name _optional_

                          Parameter change

                          amount (delta)

                          Parameter message

                          _optional_

                        method closeTo

                        closeTo: (
                        actual: number,
                        expected: number,
                        delta: number,
                        message?: string
                        ) => void;
                        • Asserts that the target is equal to expected, to within a +/- delta range.

                          Parameter actual

                          Actual value

                          Parameter expected

                          Potential expected value.

                          Parameter delta

                          Maximum differenced between values.

                          Parameter message

                          Message to display on error.

                        method containsAllDeepKeys

                        containsAllDeepKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object contains all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method containsAllKeys

                        containsAllKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object has all of the keys provided but may have more keys not listed. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method decreases

                        decreases: <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        message?: string
                        ) => void;
                        • Asserts that a function decreases an object property.

                          T Type of object.

                          Parameter modifier

                          Function to run.

                          Parameter object

                          Container object.

                          Parameter property

                          Property of object expected to be decreased.

                          Parameter message

                          Message to display on error.

                        method decreasesButNotBy

                        decreasesButNotBy: {
                        <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        change: number,
                        message?: string
                        ): void;
                        <T>(modifier: Function, object: T, change: number, message?: string): void;
                        };
                        • Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta)

                          T Type of object or function.

                          Parameter modifier

                          function

                          Parameter object

                          or getter function

                          Parameter property

                          name _optional_

                          Parameter change

                          amount (delta)

                          Parameter message

                          _optional_

                        method decreasesBy

                        decreasesBy: {
                        <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        change: number,
                        message?: string
                        ): void;
                        <T>(modifier: Function, object: T, change: number, message?: string): void;
                        };
                        • Asserts that a function decreases a numeric object property or a function's return value by an amount (delta)

                          T Type of object or function.

                          Parameter modifier

                          function

                          Parameter object

                          or getter function

                          Parameter property

                          name _optional_

                          Parameter change

                          amount (delta)

                          Parameter message

                          _optional_

                        method deepEqual

                        deepEqual: <T>(actual: T, expected: T, message?: string) => void;
                        • Asserts that actual is deeply equal to expected.

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                        method deepInclude

                        deepInclude: {
                        (haystack: string, needle: string, message?: string): void;
                        <T>(
                        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
                        needle: T,
                        message?: string
                        ): void;
                        <T>(
                        haystack: T,
                        needle: T extends WeakSet<any> ? never : Partial<T>,
                        message?: string
                        ): void;
                        };
                        • Asserts that haystack includes needle. Deep equality is used.

                          Parameter haystack

                          Container string.

                          Parameter needle

                          Potential substring of haystack.

                          Parameter message

                          Message to display on error.

                          Deprecated

                          Does not have any effect on string. Use Assert#include instead.

                        • Asserts that haystack includes needle. Deep equality is used.

                          T Type of values in haystack.

                          Parameter haystack

                          Container array, set or map.

                          Parameter needle

                          Potential value contained in haystack.

                          Parameter message

                          Message to display on error.

                        • Asserts that haystack 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;
                        • Alias to deepEqual

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                        method doesNotChange

                        doesNotChange: <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        message?: string
                        ) => void;
                        • Asserts that a function does not change the value of a property.

                          T Type of object.

                          Parameter modifier

                          Function to run.

                          Parameter object

                          Container object.

                          Parameter property

                          Property of object expected not to be modified.

                          Parameter message

                          Message to display on error.

                        method doesNotDecrease

                        doesNotDecrease: <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        message?: string
                        ) => void;
                        • Asserts that a function does not decrease an object property.

                          T Type of object.

                          Parameter modifier

                          Function to run.

                          Parameter object

                          Container object.

                          Parameter property

                          Property of object expected not to be decreased.

                          Parameter message

                          Message to display on error.

                        method doesNotDecreaseBy

                        doesNotDecreaseBy: {
                        <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        change: number,
                        message?: string
                        ): void;
                        <T>(modifier: Function, object: T, change: number, message?: string): void;
                        };
                        • Asserts that a function does not decreases a numeric object property or a function's return value by an amount (delta)

                          T Type of object or function.

                          Parameter modifier

                          function

                          Parameter object

                          or getter function

                          Parameter property

                          name _optional_

                          Parameter change

                          amount (delta)

                          Parameter message

                          _optional_

                        method doesNotHaveAllDeepKeys

                        doesNotHaveAllDeepKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object contains all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method doesNotHaveAllKeys

                        doesNotHaveAllKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object does not have at least one of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method doesNotHaveAnyDeepKeys

                        doesNotHaveAnyDeepKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object contains all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method doesNotHaveAnyKeys

                        doesNotHaveAnyKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object has none of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method doesNotIncrease

                        doesNotIncrease: <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        message?: string
                        ) => void;
                        • Asserts that a function does not increase an object property.

                          T Type of object.

                          Parameter modifier

                          Function to run.

                          Parameter object

                          Container object.

                          Parameter property

                          Property of object expected not to be increased.

                          Parameter message

                          Message to display on error.

                        method doesNotThrow

                        doesNotThrow: {
                        (
                        fn: () => void,
                        errMsgMatcher?: RegExp | string,
                        ignored?: any,
                        message?: string
                        ): void;
                        (
                        fn: () => void,
                        errorLike?: Error | ErrorConstructor,
                        errMsgMatcher?: string | RegExp,
                        message?: string
                        ): void;
                        };
                        • Asserts that fn will not throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter ignored

                          Ignored parameter.

                          Parameter message

                          Message to display on error.

                        • Asserts that fn will not throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errorLike

                          Expected error constructor or error instance.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter message

                          Message to display on error.

                        method equal

                        equal: <T>(actual: T, expected: T, message?: string) => void;
                        • Asserts non-strict equality (==) of actual and expected.

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                        method exists

                        exists: <T>(value: T, message?: string) => asserts value is NonNullable<T>;
                        • Asserts that the target is neither null nor undefined.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method extensible

                        extensible: <T>(object: T, message?: string) => void;
                        • Asserts that object is extensible (can have new properties added to it).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method fail

                        fail: {
                        (message?: string): never;
                        <T>(actual: T, expected: T, message?: string, operator?: string): never;
                        };
                        • Throws a failure.

                          Parameter message

                          Message to display on error.

                          Remarks

                          Node.js assert module-compatible.

                        • Throws a failure.

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                          Parameter operator

                          Comparison operator, if not strict equality.

                          Remarks

                          Node.js assert module-compatible.

                        method frozen

                        frozen: <T>(object: T, message?: string) => void;
                        • Asserts that object is frozen (cannot have new properties added to it and its existing properties cannot be removed).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method hasAllDeepKeys

                        hasAllDeepKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object has all and only all of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method hasAllKeys

                        hasAllKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object has all and only all of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method hasAnyDeepKeys

                        hasAnyDeepKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object has at least one of the keys provided. Since Sets and Maps can have objects as keys you can use this assertion to perform a deep comparison. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method hasAnyKeys

                        hasAnyKeys: <T>(
                        object: T,
                        keys: (string | Object)[] | { [key: string]: any },
                        message?: string
                        ) => void;
                        • Asserts that object has at least one of the keys provided. You can also provide a single object instead of a keys array and its keys will be used as the expected set of keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter keys

                          Keys to check

                          Parameter message

                          Message to display on error.

                        method ifError

                        ifError: <T>(object: T, message?: string) => void;
                        • Asserts if value is not a false value, and throws if it is a true value.

                          T Type of object.

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                          Remarks

                          This is added to allow for chai to be a drop-in replacement for Node’s assert class.

                        method include

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

                          Parameter haystack

                          Container string.

                          Parameter needle

                          Potential substring of haystack.

                          Parameter message

                          Message to display on error.

                        • Asserts that haystack includes needle.

                          T Type of values in haystack.

                          Parameter haystack

                          Container array, set or map.

                          Parameter needle

                          Potential value contained in haystack.

                          Parameter message

                          Message to display on error.

                        • Asserts that haystack includes needle.

                          T Type of values in haystack.

                          Parameter haystack

                          WeakSet container.

                          Parameter needle

                          Potential value contained in haystack.

                          Parameter message

                          Message to display on error.

                        • Asserts that haystack includes needle.

                          T Type of haystack.

                          Parameter haystack

                          Object.

                          Parameter needle

                          Potential subset of the haystack's properties.

                          Parameter message

                          Message to display on error.

                        method includeDeepMembers

                        includeDeepMembers: <T>(superset: T[], subset: T[], message?: string) => void;
                        • Asserts that subset is included in superset using deep equality checking. Order is not take into account.

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method includeDeepOrderedMembers

                        includeDeepOrderedMembers: <T>(
                        superset: T[],
                        subset: T[],
                        message?: string
                        ) => void;
                        • Asserts that subset is included in superset in the same order beginning with the first element in superset. Uses a deep equality check.

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method includeMembers

                        includeMembers: <T>(superset: T[], subset: T[], message?: string) => void;
                        • Asserts that subset is included in superset. Order is not take into account.

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method includeOrderedMembers

                        includeOrderedMembers: <T>(superset: T[], subset: T[], message?: string) => void;
                        • Asserts that subset is included in superset in the same order beginning with the first element in superset. Uses a strict equality check (===).

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method increases

                        increases: <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        message?: string
                        ) => void;
                        • Asserts that a function increases an object property.

                          T Type of object.

                          Parameter modifier

                          Function to run.

                          Parameter object

                          Container object.

                          Parameter property

                          Property of object expected to be increased.

                          Parameter message

                          Message to display on error.

                        method increasesButNotBy

                        increasesButNotBy: {
                        <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        change: number,
                        message?: string
                        ): void;
                        <T>(modifier: Function, object: T, change: number, message?: string): void;
                        };
                        • Asserts that a function does not increase a numeric object property or function's return value by an amount (delta).

                          T Type of object or function.

                          Parameter modifier

                          function

                          Parameter object

                          or getter function

                          Parameter property

                          name _optional_

                          Parameter change

                          amount (delta)

                          Parameter message

                          _optional_

                        method increasesBy

                        increasesBy: {
                        <T>(
                        modifier: Function,
                        object: T,
                        property: string,
                        change: number,
                        message?: string
                        ): void;
                        <T>(modifier: Function, object: T, change: number, message?: string): void;
                        };
                        • Asserts that a function increases a numeric object property or a function's return value by an amount (delta).

                          T Type of object or function.

                          Parameter modifier

                          function

                          Parameter object

                          or getter function

                          Parameter property

                          name _optional_

                          Parameter change

                          amount (delta)

                          Parameter message

                          _optional_

                        method instanceOf

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

                          T Expected type of value.

                          Parameter value

                          Actual value.

                          Parameter constructor

                          Potential expected contructor of value.

                          Parameter message

                          Message to display on error.

                        method isAbove

                        isAbove: (
                        valueToCheck: number,
                        valueToBeAbove: number,
                        message?: string
                        ) => void;
                        • Asserts valueToCheck is strictly greater than (>) valueToBeAbove.

                          Parameter valueToCheck

                          Actual value.

                          Parameter valueToBeAbove

                          Minimum Potential expected value.

                          Parameter message

                          Message to display on error.

                        method isArray

                        isArray: <T>(value: T, message?: string) => void;
                        • Asserts that value is an array.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isAtLeast

                        isAtLeast: (
                        valueToCheck: number,
                        valueToBeAtLeast: number,
                        message?: string
                        ) => void;
                        • Asserts valueToCheck is greater than or equal to (>=) valueToBeAtLeast.

                          Parameter valueToCheck

                          Actual value.

                          Parameter valueToBeAtLeast

                          Minimum Potential expected value.

                          Parameter message

                          Message to display on error.

                        method isAtMost

                        isAtMost: (
                        valueToCheck: number,
                        valueToBeAtMost: number,
                        message?: string
                        ) => void;
                        • Asserts valueToCheck is less than or equal to (<=) valueToBeAtMost.

                          Parameter valueToCheck

                          Actual value.

                          Parameter valueToBeAtMost

                          Minimum Potential expected value.

                          Parameter message

                          Message to display on error.

                        method isBelow

                        isBelow: (
                        valueToCheck: number,
                        valueToBeBelow: number,
                        message?: string
                        ) => void;
                        • Asserts valueToCheck is strictly less than (<) valueToBeBelow.

                          Parameter valueToCheck

                          Actual value.

                          Parameter valueToBeBelow

                          Minimum Potential expected value.

                          Parameter message

                          Message to display on error.

                        method isBoolean

                        isBoolean: <T>(value: T, message?: string) => void;
                        • Asserts that value is a boolean.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isDefined

                        isDefined: <T>(
                        value: T,
                        message?: string
                        ) => asserts value is Exclude<T, undefined>;
                        • Asserts that value is not undefined.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isEmpty

                        isEmpty: <T>(object: T, message?: string) => void;
                        • Asserts that the target does not contain any values. For arrays and strings, it checks the length property. For Map and Set instances, it checks the size property. For non-function objects, it gets the count of own enumerable string keys.

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isExtensible

                        isExtensible: <T>(object: T, message?: string) => void;
                        • Asserts that object is extensible (can have new properties added to it).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isFalse

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

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isFinite

                        isFinite: <T>(value: T, message?: string) => void;
                        • Asserts that value is a finite number. Unlike .isNumber, this will fail for NaN and Infinity.

                          T Type of value

                          Parameter value

                          Actual value

                          Parameter message

                          Message to display on error.

                        method isFrozen

                        isFrozen: <T>(object: T, message?: string) => void;
                        • Asserts that object is frozen (cannot have new properties added to it and its existing properties cannot be removed).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isFunction

                        isFunction: <T>(value: T, message?: string) => void;
                        • Asserts that value is a function.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNaN

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

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotArray

                        isNotArray: <T>(value: T, message?: string) => void;
                        • Asserts that value is not an array.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotBoolean

                        isNotBoolean: <T>(value: T, message?: string) => void;
                        • Asserts that value is not a boolean.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotEmpty

                        isNotEmpty: <T>(object: T, message?: string) => void;
                        • Asserts that the target contains values. For arrays and strings, it checks the length property. For Map and Set instances, it checks the size property. For non-function objects, it gets the count of own enumerable string keys.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter message

                          Message to display on error.

                        method isNotExtensible

                        isNotExtensible: <T>(object: T, message?: string) => void;
                        • Asserts that object is not extensible.

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotFalse

                        isNotFalse: <T>(
                        value: T,
                        message?: string
                        ) => asserts value is Exclude<T, false>;
                        • Asserts that value is not false.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotFrozen

                        isNotFrozen: <T>(object: T, message?: string) => void;
                        • Asserts that object is not frozen (cannot have new properties added to it and its existing properties cannot be removed).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotFunction

                        isNotFunction: <T>(value: T, message?: string) => void;
                        • Asserts that value is not a function.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotNaN

                        isNotNaN: <T>(value: T, message?: string) => void;
                        • Asserts that value is not NaN.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotNull

                        isNotNull: <T>(value: T, message?: string) => asserts value is Exclude<T, null>;
                        • Asserts that value is not null.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotNumber

                        isNotNumber: <T>(value: T, message?: string) => void;
                        • Asserts that value is not a number.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotObject

                        isNotObject: <T>(value: T, message?: string) => void;
                        • Asserts that value is not an object of type 'Object' (as revealed by Object.prototype.toString).

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotOk

                        isNotOk: <T>(value: T, message?: string) => void;
                        • Asserts that object is falsy.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter message

                          Message to display on error.

                        method isNotSealed

                        isNotSealed: <T>(object: T, message?: string) => void;
                        • Asserts that object is not sealed.

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotString

                        isNotString: <T>(value: T, message?: string) => void;
                        • Asserts that value is not a string.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNotTrue

                        isNotTrue: <T>(value: T, message?: string) => asserts value is Exclude<T, true>;
                        • Asserts that value is not true.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNull

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

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isNumber

                        isNumber: <T>(value: T, message?: string) => void;
                        • Asserts that value is a number.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isObject

                        isObject: <T>(value: T, message?: string) => void;
                        • Asserts that value is an object of type 'Object' (as revealed by Object.prototype.toString).

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                          Remarks

                          The assertion does not match subclassed objects.

                        method isOk

                        isOk: (value: unknown, message?: string) => asserts value;
                        • Asserts that object is truthy.

                          Parameter object

                          Object to test.

                          Parameter message

                          Message to display on error.

                        method isSealed

                        isSealed: <T>(object: T, message?: string) => void;
                        • Asserts that object is sealed (can have new properties added to it and its existing properties cannot be removed).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isString

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

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isTrue

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

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method isUndefined

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

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method lengthOf

                        lengthOf: <
                        T extends
                        | { readonly length?: number | undefined }
                        | { readonly size?: number | undefined }
                        >(
                        object: T,
                        length: number,
                        message?: string
                        ) => void;
                        • Asserts that object has a length property with the expected value.

                          T Type of object.

                          Parameter object

                          Container object.

                          Parameter length

                          Potential expected length of object.

                          Parameter message

                          Message to display on error.

                        method match

                        match: (value: string, regexp: RegExp, message?: string) => void;
                        • Asserts that value matches the regular expression regexp.

                          Parameter value

                          Actual value.

                          Parameter regexp

                          Potential match of value.

                          Parameter message

                          Message to display on error.

                        method nestedInclude

                        nestedInclude: (haystack: any, needle: any, message?: string) => void;
                        • Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object.

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

                          Parameter haystack

                          Parameter needle

                          Parameter message

                          Message to display on error.

                        method nestedProperty

                        nestedProperty: <T>(object: T, property: string, message?: string) => void;
                        • Asserts that object has a direct or inherited property named by property, which can be a string using dot- and bracket-notation for nested reference.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter property

                          Property to test.

                          Parameter message

                          Message to display on error.

                        method nestedPropertyVal

                        nestedPropertyVal: <T>(
                        object: T,
                        property: string,
                        value: any,
                        message?: string
                        ) => void;
                        • Asserts that object has a property named by property with value given by value. property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter property

                          Property to test.

                          Parameter value

                          Value to test.

                          Parameter message

                          Message to display on error.

                        method notDeepEqual

                        notDeepEqual: <T>(actual: T, expected: T, message?: string) => void;
                        • Asserts that actual is not deeply equal to expected.

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                        method notDeepInclude

                        notDeepInclude: {
                        (haystack: string, needle: string, message?: string): void;
                        <T>(
                        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
                        needle: T,
                        message?: string
                        ): void;
                        <T>(
                        haystack: T,
                        needle: T extends WeakSet<any> ? never : Partial<T>,
                        message?: string
                        ): void;
                        };
                        • Asserts that haystack does not 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: (value: unknown, message?: string) => asserts value is null;
                        • Asserts that the target is either null or undefined.

                          Parameter value

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method notExtensible

                        notExtensible: <T>(object: T, message?: string) => void;
                        • Asserts that object is not extensible.

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method notFrozen

                        notFrozen: <T>(object: T, message?: string) => void;
                        • Asserts that object is not frozen (cannot have new properties added to it and its existing properties cannot be removed).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method notInclude

                        notInclude: {
                        (haystack: string, needle: string, message?: string): void;
                        <T>(
                        haystack: readonly T[] | ReadonlySet<T> | ReadonlyMap<any, T>,
                        needle: T,
                        message?: string
                        ): void;
                        <T extends object>(haystack: WeakSet<T>, needle: T, message?: string): void;
                        <T>(haystack: T, needle: Partial<T>, message?: string): void;
                        };
                        • Asserts that haystack does not 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 notIncludeDeepMembers

                        notIncludeDeepMembers: <T>(superset: T[], subset: T[], message?: string) => void;
                        • Asserts that subset isn't included in superset in any order. Uses a deep equality check. Duplicates are ignored.

                          assert.notIncludeDeepMembers([ { a: 1 }, { b: 2 }, { c: 3 } ], [ { b: 2 }, { f: 5 } ], 'not include deep members');

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method notIncludeDeepOrderedMembers

                        notIncludeDeepOrderedMembers: <T>(
                        superset: T[],
                        subset: T[],
                        message?: string
                        ) => void;
                        • Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. Uses a deep equality check.

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method notIncludeMembers

                        notIncludeMembers: <T>(superset: T[], subset: T[], message?: string) => void;
                        • Asserts that subset isn’t included in superset in any order. Uses a strict equality check (===). Duplicates are ignored.

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential not contained set of values.

                          Parameter message

                          Message to display on error.

                        method notIncludeOrderedMembers

                        notIncludeOrderedMembers: <T>(
                        superset: T[],
                        subset: T[],
                        message?: string
                        ) => void;
                        • Asserts that subset isn’t included in superset in the same order beginning with the first element in superset. Uses a strict equality check (===).

                          T Type of set values.

                          Parameter superset

                          Actual set of values.

                          Parameter subset

                          Potential contained set of values.

                          Parameter message

                          Message to display on error.

                        method notInstanceOf

                        notInstanceOf: <T, U>(
                        value: T,
                        type: Constructor<U>,
                        message?: string
                        ) => asserts value is Exclude<T, U>;
                        • Asserts that value is not an instance of constructor.

                          T Type of value. U Type that value shouldn't be an instance of.

                          Parameter value

                          Actual value.

                          Parameter constructor

                          Potential expected contructor of value.

                          Parameter message

                          Message to display on error.

                        method notMatch

                        notMatch: (expected: any, regexp: RegExp, message?: string) => void;
                        • Asserts that value does not match the regular expression regexp.

                          Parameter value

                          Actual value.

                          Parameter regexp

                          Potential match of value.

                          Parameter message

                          Message to display on error.

                        method notNestedInclude

                        notNestedInclude: (haystack: any, needle: any, message?: string) => void;
                        • Asserts that ‘haystack’ does not include ‘needle’. Can be used to assert the absence of a subset of properties in an object.

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

                          Parameter haystack

                          Parameter needle

                          Parameter message

                          Message to display on error.

                        method notNestedProperty

                        notNestedProperty: <T>(object: T, property: string, message?: string) => void;
                        • Asserts that object does not have a property named by property, which can be a string using dot- and bracket-notation for nested reference. The property cannot exist on the object nor anywhere in its prototype chain.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter property

                          Property to test.

                          Parameter message

                          Message to display on error.

                        method notNestedPropertyVal

                        notNestedPropertyVal: <T>(
                        object: T,
                        property: string,
                        value: any,
                        message?: string
                        ) => void;
                        • Asserts that object does not have a property named by property with value given by value. property can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter property

                          Property to test.

                          Parameter value

                          Value to test.

                          Parameter message

                          Message to display on error.

                        method notOk

                        notOk: <T>(value: T, message?: string) => void;
                        • Asserts that object is falsy.

                          T Type of object.

                          Parameter object

                          Object to test.

                          Parameter message

                          Message to display on error.

                        method notOwnInclude

                        notOwnInclude: (haystack: any, needle: any, message?: string) => void;
                        • Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties.

                          Parameter haystack

                          Parameter needle

                          Parameter message

                          Message to display on error.

                        method notProperty

                        notProperty: <T>(object: T, property: string, message?: string) => void;
                        • Asserts that object 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 notSameDeepMembers

                        notSameDeepMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 don't have the same members in any order. Uses a deep equality check.

                          T Type of set values.

                          Parameter set1

                          Parameter set2

                          Parameter message

                        method notSameDeepOrderedMembers

                        notSameDeepOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 don’t have the same members in the same order. Uses a deep equality check.

                          T Type of set values.

                          Parameter set1

                          Actual set of values.

                          Parameter set2

                          Potential expected set of values.

                          Parameter message

                          Message to display on error.

                        method notSameOrderedMembers

                        notSameOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 don’t have the same members in the same order. Uses a strict equality check (===).

                          T Type of set values.

                          Parameter set1

                          Actual set of values.

                          Parameter set2

                          Potential expected set of values.

                          Parameter message

                          Message to display on error.

                        method notSealed

                        notSealed: <T>(object: T, message?: string) => void;
                        • Asserts that object is not sealed.

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method notStrictEqual

                        notStrictEqual: <T>(actual: T, expected: T, message?: string) => void;
                        • Asserts strict inequality (!==) of actual and expected.

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                        method notTypeOf

                        notTypeOf: <T>(value: T, name: string, message?: string) => void;
                        • Asserts that value's type is not name, as determined by Object.prototype.toString.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter name

                          Potential expected type name of value.

                          Parameter message

                          Message to display on error.

                        method ok

                        ok: (value: unknown, message?: string) => asserts value;
                        • Asserts that object is truthy.

                          Parameter object

                          Object to test.

                          Parameter message

                          Message to display on error.

                        method oneOf

                        oneOf: <T>(inList: T, list: T[], message?: string) => void;
                        • Asserts that non-object, non-array value inList appears in the flat array list.

                          T Type of list values.

                          Parameter inList

                          Value expected to be in the list.

                          Parameter list

                          List of values.

                          Parameter message

                          Message to display on error.

                        method operator

                        operator: (
                        val1: OperatorComparable,
                        operator: Operator,
                        val2: OperatorComparable,
                        message?: string
                        ) => void;
                        • Compares two values using operator.

                          Parameter val1

                          Left value during comparison.

                          Parameter operator

                          Comparison operator.

                          Parameter val2

                          Right value during comparison.

                          Parameter message

                          Message to display on error.

                        method ownInclude

                        ownInclude: (haystack: any, needle: any, message?: string) => void;
                        • Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties.

                          Parameter haystack

                          Parameter needle

                          Parameter message

                          Message to display on error.

                        method property

                        property: <T>(object: T, property: string, message?: string) => void;
                        • Asserts that object has a property named by property.

                          T Type of object.

                          Parameter object

                          Container object.

                          Parameter property

                          Potential contained property of object.

                          Parameter message

                          Message to display on error.

                        method propertyVal

                        propertyVal: <T, V>(
                        object: T,
                        property: string,
                        value: V,
                        message?: string
                        ) => void;
                        • Asserts that object has a property named by property with value given by value.

                          T Type of object. V Type of value.

                          Parameter object

                          Container object.

                          Parameter property

                          Potential contained property of object.

                          Parameter value

                          Potential expected property value.

                          Parameter message

                          Message to display on error.

                        method sameDeepMembers

                        sameDeepMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 have the same members using deep equality checking. Order is not take into account.

                          T Type of set values.

                          Parameter set1

                          Actual set of values.

                          Parameter set2

                          Potential expected set of values.

                          Parameter message

                          Message to display on error.

                        method sameDeepOrderedMembers

                        sameDeepOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 have the same members in the same order. Uses a deep equality check.

                          T Type of set values.

                          Parameter set1

                          Actual set of values.

                          Parameter set2

                          Potential expected set of values.

                          Parameter message

                          Message to display on error.

                        method sameMembers

                        sameMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 have the same members. Order is not take into account.

                          T Type of set values.

                          Parameter set1

                          Actual set of values.

                          Parameter set2

                          Potential expected set of values.

                          Parameter message

                          Message to display on error.

                        method sameOrderedMembers

                        sameOrderedMembers: <T>(set1: T[], set2: T[], message?: string) => void;
                        • Asserts that set1 and set2 have the same members in the same order. Uses a strict equality check (===).

                          T Type of set values.

                          Parameter set1

                          Actual set of values.

                          Parameter set2

                          Potential expected set of values.

                          Parameter message

                          Message to display on error.

                        method sealed

                        sealed: <T>(object: T, message?: string) => void;
                        • Asserts that object is sealed (can have new properties added to it and its existing properties cannot be removed).

                          T Type of object

                          Parameter object

                          Actual value.

                          Parameter message

                          Message to display on error.

                        method strictEqual

                        strictEqual: <T>(actual: T, expected: T, message?: string) => void;
                        • Asserts strict equality (===) of actual and expected.

                          T Type of the objects.

                          Parameter actual

                          Actual value.

                          Parameter expected

                          Potential expected value.

                          Parameter message

                          Message to display on error.

                        method throw

                        throw: {
                        (
                        fn: () => void,
                        errMsgMatcher?: RegExp | string,
                        ignored?: any,
                        message?: string
                        ): void;
                        (
                        fn: () => void,
                        errorLike?: Error | ErrorConstructor,
                        errMsgMatcher?: string | RegExp,
                        message?: string
                        ): void;
                        };
                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter ignored

                          Ignored parameter.

                          Parameter message

                          Message to display on error.

                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errorLike

                          Expected error constructor or error instance.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter message

                          Message to display on error.

                        method Throw

                        Throw: {
                        (
                        fn: () => void,
                        errMsgMatcher?: RegExp | string,
                        ignored?: any,
                        message?: string
                        ): void;
                        (
                        fn: () => void,
                        errorLike?: Error | ErrorConstructor,
                        errMsgMatcher?: string | RegExp,
                        message?: string
                        ): void;
                        };
                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter ignored

                          Ignored parameter.

                          Parameter message

                          Message to display on error.

                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errorLike

                          Expected error constructor or error instance.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter message

                          Message to display on error.

                        method throws

                        throws: {
                        (
                        fn: () => void,
                        errMsgMatcher?: RegExp | string,
                        ignored?: any,
                        message?: string
                        ): void;
                        (
                        fn: () => void,
                        errorLike?: Error | ErrorConstructor,
                        errMsgMatcher?: string | RegExp,
                        message?: string
                        ): void;
                        };
                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter ignored

                          Ignored parameter.

                          Parameter message

                          Message to display on error.

                        • Asserts that fn will throw an error.

                          Parameter fn

                          Function that may throw.

                          Parameter errorLike

                          Expected error constructor or error instance.

                          Parameter errMsgMatcher

                          Expected error message matcher.

                          Parameter message

                          Message to display on error.

                        method typeOf

                        typeOf: <T>(value: T, name: string, message?: string) => void;
                        • Asserts that value's type is name, as determined by Object.prototype.toString.

                          T Type of value.

                          Parameter value

                          Actual value.

                          Parameter name

                          Potential expected type name of value.

                          Parameter message

                          Message to display on error.

                        call signature

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

                          Expression to test for truthiness.

                          Parameter message

                          Message to display on error.

                        interface Assertion

                        interface Assertion extends LanguageChains, NumericComparison, TypeComparison {}

                          property a

                          a: Assertion;

                            property all

                            all: KeyFilter;

                              property an

                              an: Assertion;

                                property any

                                any: KeyFilter;

                                  property approximately

                                  approximately: CloseTo;

                                    property arguments

                                    arguments: Assertion;

                                      property Arguments

                                      Arguments: Assertion;

                                        property change

                                        change: PropertyChange;

                                          property changes

                                          changes: PropertyChange;

                                            property closeTo

                                            closeTo: CloseTo;

                                              property contain

                                              contain: Include;

                                                property contains

                                                contains: Include;

                                                  property decrease

                                                  decrease: PropertyChange;

                                                    property decreases

                                                    decreases: PropertyChange;

                                                      property deep

                                                      deep: Deep;

                                                        property empty

                                                        empty: Assertion;

                                                          property eq

                                                          eq: Equal;

                                                            property eql

                                                            eql: Equal;

                                                              property eqls

                                                              eqls: Equal;

                                                                property equal

                                                                equal: Equal;

                                                                  property equals

                                                                  equals: Equal;

                                                                    property exist

                                                                    exist: Assertion;

                                                                      property extensible

                                                                      extensible: Assertion;

                                                                        property false

                                                                        false: Assertion;

                                                                          property finite

                                                                          finite: Assertion;

                                                                            property frozen

                                                                            frozen: Assertion;

                                                                              property haveOwnProperty

                                                                              haveOwnProperty: Property;

                                                                                property haveOwnPropertyDescriptor

                                                                                haveOwnPropertyDescriptor: OwnPropertyDescriptor;

                                                                                  property include

                                                                                  include: Include;

                                                                                    property includes

                                                                                    includes: Include;

                                                                                      property increase

                                                                                      increase: PropertyChange;

                                                                                        property increases

                                                                                        increases: PropertyChange;

                                                                                          property itself

                                                                                          itself: Assertion;

                                                                                            property keys

                                                                                            keys: Keys;

                                                                                              property length

                                                                                              length: Length;

                                                                                                property lengthOf

                                                                                                lengthOf: Length;

                                                                                                  property match

                                                                                                  match: Match;

                                                                                                    property matches

                                                                                                    matches: Match;

                                                                                                      property members

                                                                                                      members: Members;

                                                                                                        property NaN

                                                                                                        NaN: Assertion;

                                                                                                          property nested

                                                                                                          nested: Nested;

                                                                                                            property not

                                                                                                            not: Assertion;

                                                                                                              property null

                                                                                                              null: Assertion;

                                                                                                                property ok

                                                                                                                ok: Assertion;

                                                                                                                  property oneOf

                                                                                                                  oneOf: OneOf;

                                                                                                                    property ordered

                                                                                                                    ordered: Ordered;

                                                                                                                      property own

                                                                                                                      own: Own;

                                                                                                                        property ownProperty

                                                                                                                        ownProperty: Property;

                                                                                                                          property ownPropertyDescriptor

                                                                                                                          ownPropertyDescriptor: OwnPropertyDescriptor;

                                                                                                                            property property

                                                                                                                            property: Property;

                                                                                                                              property respondsTo

                                                                                                                              respondsTo: RespondTo;

                                                                                                                                property respondTo

                                                                                                                                respondTo: RespondTo;

                                                                                                                                  property satisfies

                                                                                                                                  satisfies: Satisfy;

                                                                                                                                    property satisfy

                                                                                                                                    satisfy: Satisfy;

                                                                                                                                      property sealed

                                                                                                                                      sealed: Assertion;

                                                                                                                                        property throw

                                                                                                                                        throw: Throw;

                                                                                                                                          property Throw

                                                                                                                                          Throw: Throw;

                                                                                                                                            property throws

                                                                                                                                            throws: Throw;

                                                                                                                                              property true

                                                                                                                                              true: Assertion;

                                                                                                                                                property undefined

                                                                                                                                                undefined: Assertion;

                                                                                                                                                  method key

                                                                                                                                                  key: (string: string) => Assertion;

                                                                                                                                                    method string

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

                                                                                                                                                      interface AssertionPrototype

                                                                                                                                                      interface AssertionPrototype {}

                                                                                                                                                        method assert

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

                                                                                                                                                          interface AssertionStatic

                                                                                                                                                          interface AssertionStatic extends AssertionPrototype {}

                                                                                                                                                            property includeStack

                                                                                                                                                            includeStack: boolean;

                                                                                                                                                              property prototype

                                                                                                                                                              prototype: AssertionPrototype;

                                                                                                                                                                property showDiff

                                                                                                                                                                showDiff: boolean;

                                                                                                                                                                  method addChainableMethod

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

                                                                                                                                                                    method addMethod

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

                                                                                                                                                                      method addProperty

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

                                                                                                                                                                        method overwriteChainableMethod

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

                                                                                                                                                                          method overwriteMethod

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

                                                                                                                                                                            method overwriteProperty

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

                                                                                                                                                                              construct signature

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

                                                                                                                                                                                interface AssertStatic

                                                                                                                                                                                interface AssertStatic extends Assert {}

                                                                                                                                                                                  interface ChaiStatic

                                                                                                                                                                                  interface ChaiStatic {}

                                                                                                                                                                                    property assert

                                                                                                                                                                                    assert: AssertStatic;

                                                                                                                                                                                      property Assertion

                                                                                                                                                                                      Assertion: AssertionStatic;

                                                                                                                                                                                        property AssertionError

                                                                                                                                                                                        AssertionError: typeof AssertionError;

                                                                                                                                                                                          property config

                                                                                                                                                                                          config: Config;

                                                                                                                                                                                            property expect

                                                                                                                                                                                            expect: ExpectStatic;

                                                                                                                                                                                              property util

                                                                                                                                                                                              util: ChaiUtils;

                                                                                                                                                                                                property version

                                                                                                                                                                                                version: string;

                                                                                                                                                                                                  method should

                                                                                                                                                                                                  should: () => Should;

                                                                                                                                                                                                    method use

                                                                                                                                                                                                    use: (fn: ChaiPlugin) => ChaiStatic;
                                                                                                                                                                                                    • Provides a way to extend the internals of Chai

                                                                                                                                                                                                    interface ChaiUtils

                                                                                                                                                                                                    interface ChaiUtils {}

                                                                                                                                                                                                      method addChainableMethod

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

                                                                                                                                                                                                        method addLengthGuard

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

                                                                                                                                                                                                          method addMethod

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

                                                                                                                                                                                                            method addProperty

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

                                                                                                                                                                                                              method compareByInspect

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

                                                                                                                                                                                                                method compatibleConstructor

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

                                                                                                                                                                                                                  method compatibleInstance

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

                                                                                                                                                                                                                    method compatibleMessage

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

                                                                                                                                                                                                                      method expectTypes

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

                                                                                                                                                                                                                        method flag

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

                                                                                                                                                                                                                          method getActual

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

                                                                                                                                                                                                                            method getConstructorName

                                                                                                                                                                                                                            getConstructorName: (constructorFn: Function) => string;

                                                                                                                                                                                                                              method getEnumerableProperties

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

                                                                                                                                                                                                                                method getFuncName

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

                                                                                                                                                                                                                                  method getMessage

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

                                                                                                                                                                                                                                    method getOwnEnumerableProperties

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

                                                                                                                                                                                                                                      method getOwnEnumerablePropertySymbols

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

                                                                                                                                                                                                                                        method getPathInfo

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

                                                                                                                                                                                                                                          method getPathValue

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

                                                                                                                                                                                                                                            method getProperties

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

                                                                                                                                                                                                                                              method hasProperty

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

                                                                                                                                                                                                                                                method inspect

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

                                                                                                                                                                                                                                                  method isProxyEnabled

                                                                                                                                                                                                                                                  isProxyEnabled: () => boolean;

                                                                                                                                                                                                                                                    method objDisplay

                                                                                                                                                                                                                                                    objDisplay: (obj: object) => void;

                                                                                                                                                                                                                                                      method overwriteChainableMethod

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

                                                                                                                                                                                                                                                        method overwriteMethod

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

                                                                                                                                                                                                                                                          method overwriteProperty

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

                                                                                                                                                                                                                                                            method proxify

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

                                                                                                                                                                                                                                                              method test

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

                                                                                                                                                                                                                                                                method transferFlags

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

                                                                                                                                                                                                                                                                  interface CloseTo

                                                                                                                                                                                                                                                                  interface CloseTo {}

                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                      interface Config

                                                                                                                                                                                                                                                                      interface Config {}

                                                                                                                                                                                                                                                                        property includeStack

                                                                                                                                                                                                                                                                        includeStack: boolean;
                                                                                                                                                                                                                                                                        • Default: false

                                                                                                                                                                                                                                                                        property proxyExcludedKeys

                                                                                                                                                                                                                                                                        proxyExcludedKeys: string[];
                                                                                                                                                                                                                                                                        • Default: ['then', 'catch', 'inspect', 'toJSON']

                                                                                                                                                                                                                                                                        property showDiff

                                                                                                                                                                                                                                                                        showDiff: boolean;
                                                                                                                                                                                                                                                                        • Default: true

                                                                                                                                                                                                                                                                        property truncateThreshold

                                                                                                                                                                                                                                                                        truncateThreshold: number;
                                                                                                                                                                                                                                                                        • Default: 40

                                                                                                                                                                                                                                                                        property useProxy

                                                                                                                                                                                                                                                                        useProxy: boolean;
                                                                                                                                                                                                                                                                        • Default: true

                                                                                                                                                                                                                                                                        interface Constructor

                                                                                                                                                                                                                                                                        interface Constructor<T> {}

                                                                                                                                                                                                                                                                          construct signature

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

                                                                                                                                                                                                                                                                            interface Deep

                                                                                                                                                                                                                                                                            interface Deep extends KeyFilter {}

                                                                                                                                                                                                                                                                              property be

                                                                                                                                                                                                                                                                              be: Assertion;

                                                                                                                                                                                                                                                                                property contain

                                                                                                                                                                                                                                                                                contain: Include;

                                                                                                                                                                                                                                                                                  property contains

                                                                                                                                                                                                                                                                                  contains: Include;

                                                                                                                                                                                                                                                                                    property eq

                                                                                                                                                                                                                                                                                    eq: Equal;

                                                                                                                                                                                                                                                                                      property equal

                                                                                                                                                                                                                                                                                      equal: Equal;

                                                                                                                                                                                                                                                                                        property equals

                                                                                                                                                                                                                                                                                        equals: Equal;

                                                                                                                                                                                                                                                                                          property include

                                                                                                                                                                                                                                                                                          include: Include;

                                                                                                                                                                                                                                                                                            property includes

                                                                                                                                                                                                                                                                                            includes: Include;

                                                                                                                                                                                                                                                                                              property nested

                                                                                                                                                                                                                                                                                              nested: Nested;

                                                                                                                                                                                                                                                                                                property oneOf

                                                                                                                                                                                                                                                                                                oneOf: OneOf;

                                                                                                                                                                                                                                                                                                  property ordered

                                                                                                                                                                                                                                                                                                  ordered: Ordered;

                                                                                                                                                                                                                                                                                                    property own

                                                                                                                                                                                                                                                                                                    own: Own;

                                                                                                                                                                                                                                                                                                      property property

                                                                                                                                                                                                                                                                                                      property: Property;

                                                                                                                                                                                                                                                                                                        interface DeltaAssertion

                                                                                                                                                                                                                                                                                                        interface DeltaAssertion extends Assertion {}

                                                                                                                                                                                                                                                                                                          method by

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

                                                                                                                                                                                                                                                                                                            interface Equal

                                                                                                                                                                                                                                                                                                            interface Equal {}

                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                interface ErrorConstructor

                                                                                                                                                                                                                                                                                                                interface ErrorConstructor {}

                                                                                                                                                                                                                                                                                                                  construct signature

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

                                                                                                                                                                                                                                                                                                                    interface ExpectStatic

                                                                                                                                                                                                                                                                                                                    interface ExpectStatic {}

                                                                                                                                                                                                                                                                                                                      method fail

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

                                                                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                                                                          interface Include

                                                                                                                                                                                                                                                                                                                          interface Include {}

                                                                                                                                                                                                                                                                                                                            property all

                                                                                                                                                                                                                                                                                                                            all: KeyFilter;

                                                                                                                                                                                                                                                                                                                              property any

                                                                                                                                                                                                                                                                                                                              any: KeyFilter;

                                                                                                                                                                                                                                                                                                                                property deep

                                                                                                                                                                                                                                                                                                                                deep: Deep;

                                                                                                                                                                                                                                                                                                                                  property keys

                                                                                                                                                                                                                                                                                                                                  keys: Keys;

                                                                                                                                                                                                                                                                                                                                    property members

                                                                                                                                                                                                                                                                                                                                    members: Members;

                                                                                                                                                                                                                                                                                                                                      property oneOf

                                                                                                                                                                                                                                                                                                                                      oneOf: OneOf;

                                                                                                                                                                                                                                                                                                                                        property ordered

                                                                                                                                                                                                                                                                                                                                        ordered: Ordered;

                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                            interface InstanceOf

                                                                                                                                                                                                                                                                                                                                            interface InstanceOf {}

                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                interface KeyFilter

                                                                                                                                                                                                                                                                                                                                                interface KeyFilter {}

                                                                                                                                                                                                                                                                                                                                                  property keys

                                                                                                                                                                                                                                                                                                                                                  keys: Keys;

                                                                                                                                                                                                                                                                                                                                                    property members

                                                                                                                                                                                                                                                                                                                                                    members: Members;

                                                                                                                                                                                                                                                                                                                                                      interface Keys

                                                                                                                                                                                                                                                                                                                                                      interface Keys {}

                                                                                                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                            interface LanguageChains

                                                                                                                                                                                                                                                                                                                                                            interface LanguageChains {}

                                                                                                                                                                                                                                                                                                                                                              property and

                                                                                                                                                                                                                                                                                                                                                              and: Assertion;

                                                                                                                                                                                                                                                                                                                                                                property at

                                                                                                                                                                                                                                                                                                                                                                at: Assertion;

                                                                                                                                                                                                                                                                                                                                                                  property be

                                                                                                                                                                                                                                                                                                                                                                  be: Assertion;

                                                                                                                                                                                                                                                                                                                                                                    property been

                                                                                                                                                                                                                                                                                                                                                                    been: Assertion;

                                                                                                                                                                                                                                                                                                                                                                      property but

                                                                                                                                                                                                                                                                                                                                                                      but: Assertion;

                                                                                                                                                                                                                                                                                                                                                                        property does

                                                                                                                                                                                                                                                                                                                                                                        does: Assertion;

                                                                                                                                                                                                                                                                                                                                                                          property has

                                                                                                                                                                                                                                                                                                                                                                          has: Assertion;

                                                                                                                                                                                                                                                                                                                                                                            property have

                                                                                                                                                                                                                                                                                                                                                                            have: Assertion;

                                                                                                                                                                                                                                                                                                                                                                              property is

                                                                                                                                                                                                                                                                                                                                                                              is: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                property of

                                                                                                                                                                                                                                                                                                                                                                                of: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                  property same

                                                                                                                                                                                                                                                                                                                                                                                  same: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                    property that

                                                                                                                                                                                                                                                                                                                                                                                    that: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                      property to

                                                                                                                                                                                                                                                                                                                                                                                      to: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                        property which

                                                                                                                                                                                                                                                                                                                                                                                        which: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                          property with

                                                                                                                                                                                                                                                                                                                                                                                          with: Assertion;

                                                                                                                                                                                                                                                                                                                                                                                            interface Length

                                                                                                                                                                                                                                                                                                                                                                                            interface Length extends LanguageChains, NumericComparison {}

                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                interface Match

                                                                                                                                                                                                                                                                                                                                                                                                interface Match {}

                                                                                                                                                                                                                                                                                                                                                                                                  call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                    interface Members

                                                                                                                                                                                                                                                                                                                                                                                                    interface Members {}

                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                        interface Nested

                                                                                                                                                                                                                                                                                                                                                                                                        interface Nested {}

                                                                                                                                                                                                                                                                                                                                                                                                          property contain

                                                                                                                                                                                                                                                                                                                                                                                                          contain: Include;

                                                                                                                                                                                                                                                                                                                                                                                                            property contains

                                                                                                                                                                                                                                                                                                                                                                                                            contains: Include;

                                                                                                                                                                                                                                                                                                                                                                                                              property include

                                                                                                                                                                                                                                                                                                                                                                                                              include: Include;

                                                                                                                                                                                                                                                                                                                                                                                                                property includes

                                                                                                                                                                                                                                                                                                                                                                                                                includes: Include;

                                                                                                                                                                                                                                                                                                                                                                                                                  property members

                                                                                                                                                                                                                                                                                                                                                                                                                  members: Members;

                                                                                                                                                                                                                                                                                                                                                                                                                    property property

                                                                                                                                                                                                                                                                                                                                                                                                                    property: Property;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface NumberComparer

                                                                                                                                                                                                                                                                                                                                                                                                                      interface NumberComparer {}

                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                          interface NumericComparison

                                                                                                                                                                                                                                                                                                                                                                                                                          interface NumericComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property above

                                                                                                                                                                                                                                                                                                                                                                                                                            above: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                              property below

                                                                                                                                                                                                                                                                                                                                                                                                                              below: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                property greaterThan

                                                                                                                                                                                                                                                                                                                                                                                                                                greaterThan: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property greaterThanOrEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                  greaterThanOrEqual: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property gt

                                                                                                                                                                                                                                                                                                                                                                                                                                    gt: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property gte

                                                                                                                                                                                                                                                                                                                                                                                                                                      gte: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property least

                                                                                                                                                                                                                                                                                                                                                                                                                                        least: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property lessThan

                                                                                                                                                                                                                                                                                                                                                                                                                                          lessThan: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property lessThanOrEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                            lessThanOrEqual: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property lt

                                                                                                                                                                                                                                                                                                                                                                                                                                              lt: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property lte

                                                                                                                                                                                                                                                                                                                                                                                                                                                lte: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property most

                                                                                                                                                                                                                                                                                                                                                                                                                                                  most: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method within

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OneOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OneOf {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Ordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Ordered {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property members

                                                                                                                                                                                                                                                                                                                                                                                                                                                            members: Members;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Own

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Own {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property contain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                contain: Include;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property contains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  contains: Include;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    include: Include;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      includes: Include;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property: Property;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OwnPropertyDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OwnPropertyDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PathInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PathInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  exists: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parent: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Property {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PropertyChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PropertyChange {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RespondTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RespondTo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Satisfy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Satisfy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Should

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Should extends ShouldAssertion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              not: ShouldAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fail

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ShouldAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ShouldAssertion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property throw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    throw: ShouldThrow;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Throw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Throw: ShouldThrow;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method equal

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method exist

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ShouldThrow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ShouldThrow {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Throw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Throw {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TypeComparison

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TypeComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property instanceof

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          instanceof: InstanceOf;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property instanceOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            instanceOf: InstanceOf;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AssertionArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type AssertionArgs = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // '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>