@types/chai

  • Version 5.2.2
  • Published
  • 91.7 kB
  • 1 dependency
  • 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 {}

                    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 containsSubset

                                    containsSubset: (val: any, exp: any, msg?: string) => void;
                                    • Partially matches actual and expected.

                                      Parameter actual

                                      Actual value.

                                      Parameter expected

                                      Potential subset of the value.

                                      Parameter message

                                      Message to display on error.

                                    method containSubset

                                    containSubset: (val: any, exp: any, msg?: string) => void;
                                    • Partially matches actual and expected.

                                      Parameter actual

                                      Actual value.

                                      Parameter expected

                                      Potential subset of the value.

                                      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 doesNotContainSubset

                                    doesNotContainSubset: (val: any, exp: any, msg?: string) => void;
                                    • No partial match between actual and expected exists.

                                      Parameter actual

                                      Actual value.

                                      Parameter expected

                                      Potential subset of the value.

                                      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 containSubset

                                                              containSubset: ContainSubset;

                                                                property decrease

                                                                decrease: PropertyChange;

                                                                  property decreases

                                                                  decreases: PropertyChange;

                                                                    property deep

                                                                    deep: Deep;

                                                                      property empty

                                                                      empty: Assertion;

                                                                        property eq

                                                                        eq: Equal;

                                                                          property eql

                                                                          eql: Equal;

                                                                            property eqls

                                                                            eqls: Equal;

                                                                              property equal

                                                                              equal: Equal;

                                                                                property equals

                                                                                equals: Equal;

                                                                                  property exist

                                                                                  exist: Assertion;

                                                                                    property extensible

                                                                                    extensible: Assertion;

                                                                                      property false

                                                                                      false: Assertion;

                                                                                        property finite

                                                                                        finite: Assertion;

                                                                                          property frozen

                                                                                          frozen: Assertion;

                                                                                            property haveOwnProperty

                                                                                            haveOwnProperty: Property;

                                                                                              property haveOwnPropertyDescriptor

                                                                                              haveOwnPropertyDescriptor: OwnPropertyDescriptor;

                                                                                                property include

                                                                                                include: Include;

                                                                                                  property includes

                                                                                                  includes: Include;

                                                                                                    property increase

                                                                                                    increase: PropertyChange;

                                                                                                      property increases

                                                                                                      increases: PropertyChange;

                                                                                                        property itself

                                                                                                        itself: Assertion;

                                                                                                          property keys

                                                                                                          keys: Keys;

                                                                                                            property length

                                                                                                            length: Length;

                                                                                                              property lengthOf

                                                                                                              lengthOf: Length;

                                                                                                                property match

                                                                                                                match: Match;

                                                                                                                  property matches

                                                                                                                  matches: Match;

                                                                                                                    property members

                                                                                                                    members: Members;

                                                                                                                      property NaN

                                                                                                                      NaN: Assertion;

                                                                                                                        property nested

                                                                                                                        nested: Nested;

                                                                                                                          property not

                                                                                                                          not: Assertion;

                                                                                                                            property null

                                                                                                                            null: Assertion;

                                                                                                                              property ok

                                                                                                                              ok: Assertion;

                                                                                                                                property oneOf

                                                                                                                                oneOf: OneOf;

                                                                                                                                  property ordered

                                                                                                                                  ordered: Ordered;

                                                                                                                                    property own

                                                                                                                                    own: Own;

                                                                                                                                      property ownProperty

                                                                                                                                      ownProperty: Property;

                                                                                                                                        property ownPropertyDescriptor

                                                                                                                                        ownPropertyDescriptor: OwnPropertyDescriptor;

                                                                                                                                          property property

                                                                                                                                          property: Property;

                                                                                                                                            property respondsTo

                                                                                                                                            respondsTo: RespondTo;

                                                                                                                                              property respondTo

                                                                                                                                              respondTo: RespondTo;

                                                                                                                                                property satisfies

                                                                                                                                                satisfies: Satisfy;

                                                                                                                                                  property satisfy

                                                                                                                                                  satisfy: Satisfy;

                                                                                                                                                    property sealed

                                                                                                                                                    sealed: Assertion;

                                                                                                                                                      property throw

                                                                                                                                                      throw: Throw;

                                                                                                                                                        property Throw

                                                                                                                                                        Throw: Throw;

                                                                                                                                                          property throws

                                                                                                                                                          throws: Throw;

                                                                                                                                                            property true

                                                                                                                                                            true: Assertion;

                                                                                                                                                              property undefined

                                                                                                                                                              undefined: Assertion;

                                                                                                                                                                method key

                                                                                                                                                                key: (string: string) => Assertion;

                                                                                                                                                                  method string

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

                                                                                                                                                                    interface AssertionPrototype

                                                                                                                                                                    interface AssertionPrototype {}

                                                                                                                                                                      method assert

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

                                                                                                                                                                        interface AssertionStatic

                                                                                                                                                                        interface AssertionStatic extends AssertionPrototype {}

                                                                                                                                                                          property includeStack

                                                                                                                                                                          includeStack: boolean;

                                                                                                                                                                            property prototype

                                                                                                                                                                            prototype: AssertionPrototype;

                                                                                                                                                                              property showDiff

                                                                                                                                                                              showDiff: boolean;

                                                                                                                                                                                method addChainableMethod

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

                                                                                                                                                                                  method addMethod

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

                                                                                                                                                                                    method addProperty

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

                                                                                                                                                                                      method overwriteChainableMethod

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

                                                                                                                                                                                        method overwriteMethod

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

                                                                                                                                                                                          method overwriteProperty

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

                                                                                                                                                                                            construct signature

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

                                                                                                                                                                                              interface AssertStatic

                                                                                                                                                                                              interface AssertStatic extends Assert {}

                                                                                                                                                                                                interface ChaiStatic

                                                                                                                                                                                                interface ChaiStatic {}

                                                                                                                                                                                                  property assert

                                                                                                                                                                                                  assert: AssertStatic;

                                                                                                                                                                                                    property Assertion

                                                                                                                                                                                                    Assertion: AssertionStatic;

                                                                                                                                                                                                      property AssertionError

                                                                                                                                                                                                      AssertionError: typeof AssertionError;

                                                                                                                                                                                                        property config

                                                                                                                                                                                                        config: Config;

                                                                                                                                                                                                          property expect

                                                                                                                                                                                                          expect: ExpectStatic;

                                                                                                                                                                                                            property util

                                                                                                                                                                                                            util: ChaiUtils;

                                                                                                                                                                                                              property version

                                                                                                                                                                                                              version: string;

                                                                                                                                                                                                                method should

                                                                                                                                                                                                                should: () => Should;

                                                                                                                                                                                                                  method use

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

                                                                                                                                                                                                                  interface ChaiUtils

                                                                                                                                                                                                                  interface ChaiUtils {}

                                                                                                                                                                                                                    property eql

                                                                                                                                                                                                                    eql: typeof deepEqual;

                                                                                                                                                                                                                      method addChainableMethod

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

                                                                                                                                                                                                                        method addLengthGuard

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

                                                                                                                                                                                                                          method addMethod

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

                                                                                                                                                                                                                            method addProperty

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

                                                                                                                                                                                                                              method compareByInspect

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

                                                                                                                                                                                                                                method compatibleConstructor

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

                                                                                                                                                                                                                                  method compatibleInstance

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

                                                                                                                                                                                                                                    method compatibleMessage

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

                                                                                                                                                                                                                                      method expectTypes

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

                                                                                                                                                                                                                                        method flag

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

                                                                                                                                                                                                                                          method getActual

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

                                                                                                                                                                                                                                            method getConstructorName

                                                                                                                                                                                                                                            getConstructorName: (constructorFn: Function) => string;

                                                                                                                                                                                                                                              method getEnumerableProperties

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

                                                                                                                                                                                                                                                method getFuncName

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

                                                                                                                                                                                                                                                  method getMessage

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

                                                                                                                                                                                                                                                    method getOwnEnumerableProperties

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

                                                                                                                                                                                                                                                      method getOwnEnumerablePropertySymbols

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

                                                                                                                                                                                                                                                        method getPathInfo

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

                                                                                                                                                                                                                                                          method getPathValue

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

                                                                                                                                                                                                                                                            method getProperties

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

                                                                                                                                                                                                                                                              method hasProperty

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

                                                                                                                                                                                                                                                                method inspect

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

                                                                                                                                                                                                                                                                  method isProxyEnabled

                                                                                                                                                                                                                                                                  isProxyEnabled: () => boolean;

                                                                                                                                                                                                                                                                    method objDisplay

                                                                                                                                                                                                                                                                    objDisplay: (obj: object) => void;

                                                                                                                                                                                                                                                                      method overwriteChainableMethod

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

                                                                                                                                                                                                                                                                        method overwriteMethod

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

                                                                                                                                                                                                                                                                          method overwriteProperty

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

                                                                                                                                                                                                                                                                            method proxify

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

                                                                                                                                                                                                                                                                              method test

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

                                                                                                                                                                                                                                                                                method transferFlags

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

                                                                                                                                                                                                                                                                                  interface CloseTo

                                                                                                                                                                                                                                                                                  interface CloseTo {}

                                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                                      interface Config

                                                                                                                                                                                                                                                                                      interface Config {}

                                                                                                                                                                                                                                                                                        property deepEqual

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

                                                                                                                                                                                                                                                                                          property includeStack

                                                                                                                                                                                                                                                                                          includeStack: boolean;
                                                                                                                                                                                                                                                                                          • Default: false

                                                                                                                                                                                                                                                                                          property proxyExcludedKeys

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

                                                                                                                                                                                                                                                                                          property showDiff

                                                                                                                                                                                                                                                                                          showDiff: boolean;
                                                                                                                                                                                                                                                                                          • Default: true

                                                                                                                                                                                                                                                                                          property truncateThreshold

                                                                                                                                                                                                                                                                                          truncateThreshold: number;
                                                                                                                                                                                                                                                                                          • Default: 40

                                                                                                                                                                                                                                                                                          property useProxy

                                                                                                                                                                                                                                                                                          useProxy: boolean;
                                                                                                                                                                                                                                                                                          • Default: true

                                                                                                                                                                                                                                                                                          interface Constructor

                                                                                                                                                                                                                                                                                          interface Constructor<T> {}

                                                                                                                                                                                                                                                                                            construct signature

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

                                                                                                                                                                                                                                                                                              interface ContainSubset

                                                                                                                                                                                                                                                                                              interface ContainSubset {}

                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                (expected: any): Assertion;

                                                                                                                                                                                                                                                                                                  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 (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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>