@types/chai

  • Version 5.0.0
  • Published
  • 90.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 assert

const assert: Chai.AssertStatic;

    variable Assertion

    const Assertion: Chai.AssertionStatic;

      variable config

      const config: Chai.Config;

        variable expect

        const expect: Chai.ExpectStatic;

          variable util

          const util: Chai.ChaiUtils;

            Functions

            function should

            should: () => Chai.Should;

              function Should

              Should: () => Chai.Should;

                function use

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

                  Namespaces

                  namespace global

                  namespace global {}

                    interface Object

                    interface Object {}

                      property should

                      should: Chai.Assertion;

                        namespace global.Chai

                        namespace global.Chai {}

                          class AssertionError

                          class AssertionError {}

                            constructor

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

                              property message

                              message: string;

                                property name

                                name: string;

                                  property showDiff

                                  showDiff: boolean;

                                    property stack

                                    stack: string;

                                      interface Assert

                                      interface Assert {}

                                        method approximately

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

                                          Parameter actual

                                          Actual value

                                          Parameter expected

                                          Potential expected value.

                                          Parameter delta

                                          Maximum differenced between values.

                                          Parameter message

                                          Message to display on error.

                                        method changes

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

                                          T Type of object.

                                          Parameter modifier

                                          Function to run.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Property of object expected to be modified.

                                          Parameter message

                                          Message to display on error.

                                        method changesBy

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

                                          Parameter modifier

                                          function

                                          Parameter object

                                          or getter function

                                          Parameter property

                                          name _optional_

                                          Parameter change

                                          amount (delta)

                                          Parameter message

                                          _optional_

                                        method closeTo

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

                                          Parameter actual

                                          Actual value

                                          Parameter expected

                                          Potential expected value.

                                          Parameter delta

                                          Maximum differenced between values.

                                          Parameter message

                                          Message to display on error.

                                        method containsAllDeepKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method containsAllKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method decreases

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

                                          T Type of object.

                                          Parameter modifier

                                          Function to run.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Property of object expected to be decreased.

                                          Parameter message

                                          Message to display on error.

                                        method decreasesButNotBy

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

                                          T Type of object or function.

                                          Parameter modifier

                                          function

                                          Parameter object

                                          or getter function

                                          Parameter property

                                          name _optional_

                                          Parameter change

                                          amount (delta)

                                          Parameter message

                                          _optional_

                                        method decreasesBy

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

                                          T Type of object or function.

                                          Parameter modifier

                                          function

                                          Parameter object

                                          or getter function

                                          Parameter property

                                          name _optional_

                                          Parameter change

                                          amount (delta)

                                          Parameter message

                                          _optional_

                                        method deepEqual

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method deepInclude

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

                                          Parameter haystack

                                          Container string.

                                          Parameter needle

                                          Potential substring of haystack.

                                          Parameter message

                                          Message to display on error.

                                          Deprecated

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

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

                                          T Type of values in haystack.

                                          Parameter haystack

                                          Container array, set or map.

                                          Parameter needle

                                          Potential value contained in haystack.

                                          Parameter message

                                          Message to display on error.

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

                                          T Type of haystack.

                                          Parameter haystack

                                          Object.

                                          Parameter needle

                                          Potential subset of the haystack's properties.

                                          Parameter message

                                          Message to display on error.

                                        method deepNestedInclude

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

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method deepNestedPropertyVal

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter property

                                          Property to test.

                                          Parameter value

                                          Value to test.

                                          Parameter message

                                          Message to display on error.

                                        method deepOwnInclude

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method deepProperty

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

                                          T Type of object.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter message

                                          Message to display on error.

                                        method deepPropertyVal

                                        deepPropertyVal: <T, V>(
                                        object: T,
                                        property: string,
                                        value: V,
                                        message?: string
                                        ) => void;
                                        • Asserts that object has a property named by property, which can be a string using dot- and bracket-notation for deep reference.

                                          T Type of object. V Type of value.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter value

                                          Potential expected property value.

                                          Parameter message

                                          Message to display on error.

                                        method deepStrictEqual

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method doesNotChange

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

                                          T Type of object.

                                          Parameter modifier

                                          Function to run.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Property of object expected not to be modified.

                                          Parameter message

                                          Message to display on error.

                                        method doesNotDecrease

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

                                          T Type of object.

                                          Parameter modifier

                                          Function to run.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Property of object expected not to be decreased.

                                          Parameter message

                                          Message to display on error.

                                        method doesNotDecreaseBy

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

                                          T Type of object or function.

                                          Parameter modifier

                                          function

                                          Parameter object

                                          or getter function

                                          Parameter property

                                          name _optional_

                                          Parameter change

                                          amount (delta)

                                          Parameter message

                                          _optional_

                                        method doesNotHaveAllDeepKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method doesNotHaveAllKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method doesNotHaveAnyDeepKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method doesNotHaveAnyKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method doesNotIncrease

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

                                          T Type of object.

                                          Parameter modifier

                                          Function to run.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Property of object expected not to be increased.

                                          Parameter message

                                          Message to display on error.

                                        method doesNotThrow

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

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter ignored

                                          Ignored parameter.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that fn will not throw an error.

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errorLike

                                          Expected error constructor or error instance.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter message

                                          Message to display on error.

                                        method equal

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method exists

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method extensible

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method fail

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

                                          Parameter message

                                          Message to display on error.

                                          Remarks

                                          Node.js assert module-compatible.

                                        • Throws a failure.

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                          Parameter operator

                                          Comparison operator, if not strict equality.

                                          Remarks

                                          Node.js assert module-compatible.

                                        method frozen

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method hasAllDeepKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method hasAllKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method hasAnyDeepKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method hasAnyKeys

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter keys

                                          Keys to check

                                          Parameter message

                                          Message to display on error.

                                        method ifError

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

                                          T Type of object.

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                          Remarks

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

                                        method include

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

                                          Parameter haystack

                                          Container string.

                                          Parameter needle

                                          Potential substring of haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack includes needle.

                                          T Type of values in haystack.

                                          Parameter haystack

                                          Container array, set or map.

                                          Parameter needle

                                          Potential value contained in haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack includes needle.

                                          T Type of values in haystack.

                                          Parameter haystack

                                          WeakSet container.

                                          Parameter needle

                                          Potential value contained in haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack includes needle.

                                          T Type of haystack.

                                          Parameter haystack

                                          Object.

                                          Parameter needle

                                          Potential subset of the haystack's properties.

                                          Parameter message

                                          Message to display on error.

                                        method includeDeepMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method includeDeepOrderedMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method includeMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method includeOrderedMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method increases

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

                                          T Type of object.

                                          Parameter modifier

                                          Function to run.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Property of object expected to be increased.

                                          Parameter message

                                          Message to display on error.

                                        method increasesButNotBy

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

                                          T Type of object or function.

                                          Parameter modifier

                                          function

                                          Parameter object

                                          or getter function

                                          Parameter property

                                          name _optional_

                                          Parameter change

                                          amount (delta)

                                          Parameter message

                                          _optional_

                                        method increasesBy

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

                                          T Type of object or function.

                                          Parameter modifier

                                          function

                                          Parameter object

                                          or getter function

                                          Parameter property

                                          name _optional_

                                          Parameter change

                                          amount (delta)

                                          Parameter message

                                          _optional_

                                        method instanceOf

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

                                          T Expected type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter constructor

                                          Potential expected contructor of value.

                                          Parameter message

                                          Message to display on error.

                                        method isAbove

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

                                          Parameter valueToCheck

                                          Actual value.

                                          Parameter valueToBeAbove

                                          Minimum Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method isArray

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isAtLeast

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

                                          Parameter valueToCheck

                                          Actual value.

                                          Parameter valueToBeAtLeast

                                          Minimum Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method isAtMost

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

                                          Parameter valueToCheck

                                          Actual value.

                                          Parameter valueToBeAtMost

                                          Minimum Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method isBelow

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

                                          Parameter valueToCheck

                                          Actual value.

                                          Parameter valueToBeBelow

                                          Minimum Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method isBoolean

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isDefined

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isEmpty

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isExtensible

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isFalse

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

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isFinite

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

                                          T Type of value

                                          Parameter value

                                          Actual value

                                          Parameter message

                                          Message to display on error.

                                        method isFrozen

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isFunction

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNaN

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotArray

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotBoolean

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotEmpty

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter message

                                          Message to display on error.

                                        method isNotExtensible

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotFalse

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

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotFrozen

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotFunction

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotNaN

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotNull

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotNumber

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotObject

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotOk

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter message

                                          Message to display on error.

                                        method isNotSealed

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotString

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNotTrue

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNull

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

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isNumber

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isObject

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                          Remarks

                                          The assertion does not match subclassed objects.

                                        method isOk

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

                                          Parameter object

                                          Object to test.

                                          Parameter message

                                          Message to display on error.

                                        method isSealed

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isString

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isTrue

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

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method isUndefined

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

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method lengthOf

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

                                          T Type of object.

                                          Parameter object

                                          Container object.

                                          Parameter length

                                          Potential expected length of object.

                                          Parameter message

                                          Message to display on error.

                                        method match

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

                                          Parameter value

                                          Actual value.

                                          Parameter regexp

                                          Potential match of value.

                                          Parameter message

                                          Message to display on error.

                                        method nestedInclude

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

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method nestedProperty

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter property

                                          Property to test.

                                          Parameter message

                                          Message to display on error.

                                        method nestedPropertyVal

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter property

                                          Property to test.

                                          Parameter value

                                          Value to test.

                                          Parameter message

                                          Message to display on error.

                                        method notDeepEqual

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method notDeepInclude

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

                                          Parameter haystack

                                          Container string.

                                          Parameter needle

                                          Potential substring of haystack.

                                          Parameter message

                                          Message to display on error.

                                          Deprecated

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

                                        • Asserts that haystack does not include needle. Deep equality is used.

                                          T Type of values in haystack.

                                          Parameter haystack

                                          Container array, set or map.

                                          Parameter needle

                                          Potential value contained in haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack does not include needle. Deep equality is used.

                                          T Type of haystack.

                                          Parameter haystack

                                          Object.

                                          Parameter needle

                                          Potential subset of the haystack's properties.

                                          Parameter message

                                          Message to display on error.

                                        method notDeepNestedInclude

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

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method notDeepNestedPropertyVal

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter property

                                          Property to test.

                                          Parameter value

                                          Value to test.

                                          Parameter message

                                          Message to display on error.

                                        method notDeepOwnInclude

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method notDeepProperty

                                        notDeepProperty: <T>(object: T, property: string, message?: string) => void;
                                        • Asserts that object does not have a property named by property, which can be a string using dot- and bracket-notation for deep reference.

                                          T Type of object.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter message

                                          Message to display on error.

                                        method notDeepPropertyVal

                                        notDeepPropertyVal: <T, V>(
                                        object: T,
                                        property: string,
                                        value: V,
                                        message?: string
                                        ) => void;
                                        • Asserts that object does not have a property named by property, which can be a string using dot- and bracket-notation for deep reference.

                                          T Type of object. V Type of value.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter value

                                          Potential expected property value.

                                          Parameter message

                                          Message to display on error.

                                        method notEqual

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method notExists

                                        notExists: (value: unknown, message?: string) => asserts value is null;
                                        • Asserts that the target is either null or undefined.

                                          Parameter value

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method notExtensible

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method notFrozen

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method notInclude

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

                                          Parameter haystack

                                          Container string.

                                          Parameter needle

                                          Potential substring of haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack does not include needle.

                                          T Type of values in haystack.

                                          Parameter haystack

                                          Container array, set or map.

                                          Parameter needle

                                          Potential value contained in haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack does not include needle.

                                          T Type of values in haystack.

                                          Parameter haystack

                                          WeakSet container.

                                          Parameter needle

                                          Potential value contained in haystack.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that haystack does not include needle.

                                          T Type of haystack.

                                          Parameter haystack

                                          Object.

                                          Parameter needle

                                          Potential subset of the haystack's properties.

                                          Parameter message

                                          Message to display on error.

                                        method notIncludeDeepMembers

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

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method notIncludeDeepOrderedMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method notIncludeMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential not contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method notIncludeOrderedMembers

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

                                          T Type of set values.

                                          Parameter superset

                                          Actual set of values.

                                          Parameter subset

                                          Potential contained set of values.

                                          Parameter message

                                          Message to display on error.

                                        method notInstanceOf

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

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

                                          Parameter value

                                          Actual value.

                                          Parameter constructor

                                          Potential expected contructor of value.

                                          Parameter message

                                          Message to display on error.

                                        method notMatch

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

                                          Parameter value

                                          Actual value.

                                          Parameter regexp

                                          Potential match of value.

                                          Parameter message

                                          Message to display on error.

                                        method notNestedInclude

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

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method notNestedProperty

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter property

                                          Property to test.

                                          Parameter message

                                          Message to display on error.

                                        method notNestedPropertyVal

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter property

                                          Property to test.

                                          Parameter value

                                          Value to test.

                                          Parameter message

                                          Message to display on error.

                                        method notOk

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

                                          T Type of object.

                                          Parameter object

                                          Object to test.

                                          Parameter message

                                          Message to display on error.

                                        method notOwnInclude

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method notProperty

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

                                          T Type of object.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter message

                                          Message to display on error.

                                        method notPropertyVal

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

                                          T Type of object. V Type of value.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter value

                                          Potential expected property value.

                                          Parameter message

                                          Message to display on error.

                                        method notSameDeepMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Parameter set2

                                          Parameter message

                                        method notSameDeepOrderedMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Actual set of values.

                                          Parameter set2

                                          Potential expected set of values.

                                          Parameter message

                                          Message to display on error.

                                        method notSameOrderedMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Actual set of values.

                                          Parameter set2

                                          Potential expected set of values.

                                          Parameter message

                                          Message to display on error.

                                        method notSealed

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method notStrictEqual

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method notTypeOf

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter name

                                          Potential expected type name of value.

                                          Parameter message

                                          Message to display on error.

                                        method ok

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

                                          Parameter object

                                          Object to test.

                                          Parameter message

                                          Message to display on error.

                                        method oneOf

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

                                          T Type of list values.

                                          Parameter inList

                                          Value expected to be in the list.

                                          Parameter list

                                          List of values.

                                          Parameter message

                                          Message to display on error.

                                        method operator

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

                                          Parameter val1

                                          Left value during comparison.

                                          Parameter operator

                                          Comparison operator.

                                          Parameter val2

                                          Right value during comparison.

                                          Parameter message

                                          Message to display on error.

                                        method ownInclude

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

                                          Parameter haystack

                                          Parameter needle

                                          Parameter message

                                          Message to display on error.

                                        method property

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

                                          T Type of object.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter message

                                          Message to display on error.

                                        method propertyVal

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

                                          T Type of object. V Type of value.

                                          Parameter object

                                          Container object.

                                          Parameter property

                                          Potential contained property of object.

                                          Parameter value

                                          Potential expected property value.

                                          Parameter message

                                          Message to display on error.

                                        method sameDeepMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Actual set of values.

                                          Parameter set2

                                          Potential expected set of values.

                                          Parameter message

                                          Message to display on error.

                                        method sameDeepOrderedMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Actual set of values.

                                          Parameter set2

                                          Potential expected set of values.

                                          Parameter message

                                          Message to display on error.

                                        method sameMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Actual set of values.

                                          Parameter set2

                                          Potential expected set of values.

                                          Parameter message

                                          Message to display on error.

                                        method sameOrderedMembers

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

                                          T Type of set values.

                                          Parameter set1

                                          Actual set of values.

                                          Parameter set2

                                          Potential expected set of values.

                                          Parameter message

                                          Message to display on error.

                                        method sealed

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

                                          T Type of object

                                          Parameter object

                                          Actual value.

                                          Parameter message

                                          Message to display on error.

                                        method strictEqual

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

                                          T Type of the objects.

                                          Parameter actual

                                          Actual value.

                                          Parameter expected

                                          Potential expected value.

                                          Parameter message

                                          Message to display on error.

                                        method throw

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

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter ignored

                                          Ignored parameter.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that fn will throw an error.

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errorLike

                                          Expected error constructor or error instance.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter message

                                          Message to display on error.

                                        method Throw

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

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter ignored

                                          Ignored parameter.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that fn will throw an error.

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errorLike

                                          Expected error constructor or error instance.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter message

                                          Message to display on error.

                                        method throws

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

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter ignored

                                          Ignored parameter.

                                          Parameter message

                                          Message to display on error.

                                        • Asserts that fn will throw an error.

                                          Parameter fn

                                          Function that may throw.

                                          Parameter errorLike

                                          Expected error constructor or error instance.

                                          Parameter errMsgMatcher

                                          Expected error message matcher.

                                          Parameter message

                                          Message to display on error.

                                        method typeOf

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

                                          T Type of value.

                                          Parameter value

                                          Actual value.

                                          Parameter name

                                          Potential expected type name of value.

                                          Parameter message

                                          Message to display on error.

                                        call signature

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

                                          Expression to test for truthiness.

                                          Parameter message

                                          Message to display on error.

                                        interface Assertion

                                        interface Assertion extends LanguageChains, NumericComparison, TypeComparison {}

                                          property a

                                          a: Assertion;

                                            property all

                                            all: KeyFilter;

                                              property an

                                              an: Assertion;

                                                property any

                                                any: KeyFilter;

                                                  property approximately

                                                  approximately: CloseTo;

                                                    property arguments

                                                    arguments: Assertion;

                                                      property Arguments

                                                      Arguments: Assertion;

                                                        property change

                                                        change: PropertyChange;

                                                          property changes

                                                          changes: PropertyChange;

                                                            property closeTo

                                                            closeTo: CloseTo;

                                                              property contain

                                                              contain: Include;

                                                                property contains

                                                                contains: Include;

                                                                  property decrease

                                                                  decrease: PropertyChange;

                                                                    property decreases

                                                                    decreases: PropertyChange;

                                                                      property deep

                                                                      deep: Deep;

                                                                        property empty

                                                                        empty: Assertion;

                                                                          property eq

                                                                          eq: Equal;

                                                                            property eql

                                                                            eql: Equal;

                                                                              property eqls

                                                                              eqls: Equal;

                                                                                property equal

                                                                                equal: Equal;

                                                                                  property equals

                                                                                  equals: Equal;

                                                                                    property exist

                                                                                    exist: Assertion;

                                                                                      property extensible

                                                                                      extensible: Assertion;

                                                                                        property false

                                                                                        false: Assertion;

                                                                                          property finite

                                                                                          finite: Assertion;

                                                                                            property frozen

                                                                                            frozen: Assertion;

                                                                                              property haveOwnProperty

                                                                                              haveOwnProperty: Property;

                                                                                                property haveOwnPropertyDescriptor

                                                                                                haveOwnPropertyDescriptor: OwnPropertyDescriptor;

                                                                                                  property include

                                                                                                  include: Include;

                                                                                                    property includes

                                                                                                    includes: Include;

                                                                                                      property increase

                                                                                                      increase: PropertyChange;

                                                                                                        property increases

                                                                                                        increases: PropertyChange;

                                                                                                          property itself

                                                                                                          itself: Assertion;

                                                                                                            property keys

                                                                                                            keys: Keys;

                                                                                                              property length

                                                                                                              length: Length;

                                                                                                                property lengthOf

                                                                                                                lengthOf: Length;

                                                                                                                  property match

                                                                                                                  match: Match;

                                                                                                                    property matches

                                                                                                                    matches: Match;

                                                                                                                      property members

                                                                                                                      members: Members;

                                                                                                                        property NaN

                                                                                                                        NaN: Assertion;

                                                                                                                          property nested

                                                                                                                          nested: Nested;

                                                                                                                            property not

                                                                                                                            not: Assertion;

                                                                                                                              property null

                                                                                                                              null: Assertion;

                                                                                                                                property ok

                                                                                                                                ok: Assertion;

                                                                                                                                  property oneOf

                                                                                                                                  oneOf: OneOf;

                                                                                                                                    property ordered

                                                                                                                                    ordered: Ordered;

                                                                                                                                      property own

                                                                                                                                      own: Own;

                                                                                                                                        property ownProperty

                                                                                                                                        ownProperty: Property;

                                                                                                                                          property ownPropertyDescriptor

                                                                                                                                          ownPropertyDescriptor: OwnPropertyDescriptor;

                                                                                                                                            property property

                                                                                                                                            property: Property;

                                                                                                                                              property respondsTo

                                                                                                                                              respondsTo: RespondTo;

                                                                                                                                                property respondTo

                                                                                                                                                respondTo: RespondTo;

                                                                                                                                                  property satisfies

                                                                                                                                                  satisfies: Satisfy;

                                                                                                                                                    property satisfy

                                                                                                                                                    satisfy: Satisfy;

                                                                                                                                                      property sealed

                                                                                                                                                      sealed: Assertion;

                                                                                                                                                        property throw

                                                                                                                                                        throw: Throw;

                                                                                                                                                          property Throw

                                                                                                                                                          Throw: Throw;

                                                                                                                                                            property throws

                                                                                                                                                            throws: Throw;

                                                                                                                                                              property true

                                                                                                                                                              true: Assertion;

                                                                                                                                                                property undefined

                                                                                                                                                                undefined: Assertion;

                                                                                                                                                                  method key

                                                                                                                                                                  key: (string: string) => Assertion;

                                                                                                                                                                    method string

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

                                                                                                                                                                      interface AssertionPrototype

                                                                                                                                                                      interface AssertionPrototype {}

                                                                                                                                                                        method assert

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

                                                                                                                                                                          interface AssertionStatic

                                                                                                                                                                          interface AssertionStatic extends AssertionPrototype {}

                                                                                                                                                                            property includeStack

                                                                                                                                                                            includeStack: boolean;

                                                                                                                                                                              property prototype

                                                                                                                                                                              prototype: AssertionPrototype;

                                                                                                                                                                                property showDiff

                                                                                                                                                                                showDiff: boolean;

                                                                                                                                                                                  method addChainableMethod

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

                                                                                                                                                                                    method addMethod

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

                                                                                                                                                                                      method addProperty

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

                                                                                                                                                                                        method overwriteChainableMethod

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

                                                                                                                                                                                          method overwriteMethod

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

                                                                                                                                                                                            method overwriteProperty

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

                                                                                                                                                                                              construct signature

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

                                                                                                                                                                                                interface AssertStatic

                                                                                                                                                                                                interface AssertStatic extends Assert {}

                                                                                                                                                                                                  interface ChaiStatic

                                                                                                                                                                                                  interface ChaiStatic {}

                                                                                                                                                                                                    property assert

                                                                                                                                                                                                    assert: AssertStatic;

                                                                                                                                                                                                      property Assertion

                                                                                                                                                                                                      Assertion: AssertionStatic;

                                                                                                                                                                                                        property AssertionError

                                                                                                                                                                                                        AssertionError: typeof AssertionError;

                                                                                                                                                                                                          property config

                                                                                                                                                                                                          config: Config;

                                                                                                                                                                                                            property expect

                                                                                                                                                                                                            expect: ExpectStatic;

                                                                                                                                                                                                              property util

                                                                                                                                                                                                              util: ChaiUtils;

                                                                                                                                                                                                                property version

                                                                                                                                                                                                                version: string;

                                                                                                                                                                                                                  method should

                                                                                                                                                                                                                  should: () => Should;

                                                                                                                                                                                                                    method use

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

                                                                                                                                                                                                                    interface ChaiUtils

                                                                                                                                                                                                                    interface ChaiUtils {}

                                                                                                                                                                                                                      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 = [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                any, // expression to be tested
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Message, // message or function that returns message to display if expression fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Message, // negatedMessage or function that returns negatedMessage to display if expression fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                any?, // expected value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                any?, // actual value
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                boolean? // showDiff, when set to `true`, assert will display a diff in addition to the message if expression fails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChaiPlugin

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Message

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ObjectProperty = string | symbol | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Operator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Operator = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OperatorComparable

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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>