@types/chai-as-promised

  • Version 7.1.4
  • Published
  • 24.7 kB
  • 1 dependency
  • MIT license

Install

npm i @types/chai-as-promised
yarn add @types/chai-as-promised
pnpm add @types/chai-as-promised

Overview

TypeScript definitions for chai-as-promised

Index

Namespaces

namespace Chai

namespace Chai {}

    interface Assert

    interface Assert {}

      property eventually

      eventually: PromisedAssert;

        method becomes

        becomes: (
        promise: PromiseLike<any>,
        expected: any,
        message?: string
        ) => PromiseLike<void>;

          method doesNotBecome

          doesNotBecome: (
          promise: PromiseLike<any>,
          expected: any,
          message?: string
          ) => PromiseLike<void>;

            method isFulfilled

            isFulfilled: (promise: PromiseLike<any>, message?: string) => PromiseLike<void>;

              method isRejected

              isRejected: {
              (promise: PromiseLike<any>, message?: string): PromiseLike<void>;
              (
              promise: PromiseLike<any>,
              expected: any,
              message?: string
              ): PromiseLike<void>;
              (
              promise: PromiseLike<any>,
              match: RegExp,
              message?: string
              ): PromiseLike<void>;
              };

                method notify

                notify: (fn: Function) => PromiseLike<void>;

                  interface Assertion

                  interface Assertion extends LanguageChains, NumericComparison, TypeComparison {}

                    property eventually

                    eventually: PromisedAssertion;

                      property fulfilled

                      fulfilled: PromisedAssertion;

                        property rejected

                        rejected: PromisedAssertion;

                          property rejectedWith

                          rejectedWith: PromisedThrow;

                            method become

                            become: (expected: any) => PromisedAssertion;

                              method notify

                              notify: (fn: Function) => PromisedAssertion;

                                interface Eventually

                                interface Eventually
                                extends PromisedLanguageChains,
                                PromisedNumericComparison,
                                PromisedTypeComparison {}

                                  property a

                                  a: PromisedTypeComparison;

                                    property all

                                    all: PromisedKeyFilter;

                                      property an

                                      an: PromisedTypeComparison;

                                        property any

                                        any: PromisedKeyFilter;

                                          property approximately

                                          approximately: PromisedCloseTo;

                                            property arguments

                                            arguments: PromisedAssertion;

                                              property Arguments

                                              Arguments: PromisedAssertion;

                                                property change

                                                change: PromisedPropertyChange;

                                                  property changes

                                                  changes: PromisedPropertyChange;

                                                    property closeTo

                                                    closeTo: PromisedCloseTo;

                                                      property contain

                                                      contain: PromisedInclude;

                                                        property decrease

                                                        decrease: PromisedPropertyChange;

                                                          property decreases

                                                          decreases: PromisedPropertyChange;

                                                            property deep

                                                            deep: PromisedDeep;

                                                              property empty

                                                              empty: PromisedAssertion;

                                                                property eq

                                                                eq: PromisedEqual;

                                                                  property eql

                                                                  eql: PromisedEqual;

                                                                    property eqls

                                                                    eqls: PromisedEqual;

                                                                      property equal

                                                                      equal: PromisedEqual;

                                                                        property equals

                                                                        equals: PromisedEqual;

                                                                          property exist

                                                                          exist: PromisedAssertion;

                                                                            property extensible

                                                                            extensible: PromisedAssertion;

                                                                              property false

                                                                              false: PromisedAssertion;

                                                                                property frozen

                                                                                frozen: PromisedAssertion;

                                                                                  property fulfilled

                                                                                  fulfilled: PromisedAssertion;

                                                                                    property haveOwnProperty

                                                                                    haveOwnProperty: PromisedOwnProperty;

                                                                                      property haveOwnPropertyDescriptor

                                                                                      haveOwnPropertyDescriptor: PromisedOwnPropertyDescriptor;

                                                                                        property include

                                                                                        include: PromisedInclude;

                                                                                          property increase

                                                                                          increase: PromisedPropertyChange;

                                                                                            property increases

                                                                                            increases: PromisedPropertyChange;

                                                                                              property itself

                                                                                              itself: PromisedAssertion;

                                                                                                property keys

                                                                                                keys: PromisedKeys;

                                                                                                  property length

                                                                                                  length: PromisedLength;

                                                                                                    property lengthOf

                                                                                                    lengthOf: PromisedLength;

                                                                                                      property match

                                                                                                      match: PromisedMatch;

                                                                                                        property matches

                                                                                                        matches: PromisedMatch;

                                                                                                          property members

                                                                                                          members: PromisedMembers;

                                                                                                            property NaN

                                                                                                            NaN: PromisedAssertion;

                                                                                                              property nested

                                                                                                              nested: PromisedNested;

                                                                                                                property not

                                                                                                                not: PromisedAssertion;

                                                                                                                  property null

                                                                                                                  null: PromisedAssertion;

                                                                                                                    property ok

                                                                                                                    ok: PromisedAssertion;

                                                                                                                      property ordered

                                                                                                                      ordered: PromisedOrdered;

                                                                                                                        property ownProperty

                                                                                                                        ownProperty: PromisedOwnProperty;

                                                                                                                          property ownPropertyDescriptor

                                                                                                                          ownPropertyDescriptor: PromisedOwnPropertyDescriptor;

                                                                                                                            property property

                                                                                                                            property: PromisedProperty;

                                                                                                                              property rejected

                                                                                                                              rejected: PromisedAssertion;

                                                                                                                                property rejectedWith

                                                                                                                                rejectedWith: PromisedThrow;

                                                                                                                                  property respondsTo

                                                                                                                                  respondsTo: PromisedRespondTo;

                                                                                                                                    property respondTo

                                                                                                                                    respondTo: PromisedRespondTo;

                                                                                                                                      property satisfies

                                                                                                                                      satisfies: PromisedSatisfy;

                                                                                                                                        property satisfy

                                                                                                                                        satisfy: PromisedSatisfy;

                                                                                                                                          property sealed

                                                                                                                                          sealed: PromisedAssertion;

                                                                                                                                            property throw

                                                                                                                                            throw: PromisedThrow;

                                                                                                                                              property Throw

                                                                                                                                              Throw: PromisedThrow;

                                                                                                                                                property throws

                                                                                                                                                throws: PromisedThrow;

                                                                                                                                                  property true

                                                                                                                                                  true: PromisedAssertion;

                                                                                                                                                    property undefined

                                                                                                                                                    undefined: PromisedAssertion;

                                                                                                                                                      method become

                                                                                                                                                      become: (expected: any) => PromisedAssertion;

                                                                                                                                                        method key

                                                                                                                                                        key: (string: string) => PromisedAssertion;

                                                                                                                                                          method notify

                                                                                                                                                          notify: (fn: Function) => PromisedAssertion;

                                                                                                                                                            method oneOf

                                                                                                                                                            oneOf: (list: any[], message?: string) => PromisedAssertion;

                                                                                                                                                              method string

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

                                                                                                                                                                interface PromisedAssert

                                                                                                                                                                interface PromisedAssert {}

                                                                                                                                                                  method approximately

                                                                                                                                                                  approximately: (
                                                                                                                                                                  act: number,
                                                                                                                                                                  exp: number,
                                                                                                                                                                  delta: number,
                                                                                                                                                                  msg?: string
                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                    method changes

                                                                                                                                                                    changes: (
                                                                                                                                                                    modifier: Function,
                                                                                                                                                                    obj: Object,
                                                                                                                                                                    property: string,
                                                                                                                                                                    msg?: string
                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                      method changesButNotBy

                                                                                                                                                                      changesButNotBy: (
                                                                                                                                                                      modifier: Function,
                                                                                                                                                                      obj: object,
                                                                                                                                                                      property: string,
                                                                                                                                                                      change: number,
                                                                                                                                                                      msg?: string
                                                                                                                                                                      ) => PromiseLike<void>;

                                                                                                                                                                        method changesBy

                                                                                                                                                                        changesBy: (
                                                                                                                                                                        modifier: Function,
                                                                                                                                                                        obj: object,
                                                                                                                                                                        property: string,
                                                                                                                                                                        change: number,
                                                                                                                                                                        msg?: string
                                                                                                                                                                        ) => PromiseLike<void>;

                                                                                                                                                                          method closeTo

                                                                                                                                                                          closeTo: (
                                                                                                                                                                          act: number,
                                                                                                                                                                          exp: number,
                                                                                                                                                                          delta: number,
                                                                                                                                                                          msg?: string
                                                                                                                                                                          ) => PromiseLike<void>;

                                                                                                                                                                            method containsAllDeepKeys

                                                                                                                                                                            containsAllDeepKeys: {
                                                                                                                                                                            (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                            (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                            };

                                                                                                                                                                              method containsAllKeys

                                                                                                                                                                              containsAllKeys: {
                                                                                                                                                                              (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                              (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                              };

                                                                                                                                                                                method decreases

                                                                                                                                                                                decreases: (
                                                                                                                                                                                modifier: Function,
                                                                                                                                                                                obj: Object,
                                                                                                                                                                                property: string,
                                                                                                                                                                                msg?: string
                                                                                                                                                                                ) => PromiseLike<void>;

                                                                                                                                                                                  method decreasesButNotBy

                                                                                                                                                                                  decreasesButNotBy: (
                                                                                                                                                                                  modifier: Function,
                                                                                                                                                                                  obj: Object,
                                                                                                                                                                                  property: string,
                                                                                                                                                                                  change: number,
                                                                                                                                                                                  msg?: string
                                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                                    method decreasesBy

                                                                                                                                                                                    decreasesBy: (
                                                                                                                                                                                    modifier: Function,
                                                                                                                                                                                    obj: Object,
                                                                                                                                                                                    property: string,
                                                                                                                                                                                    change: number,
                                                                                                                                                                                    msg?: string
                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                      method deepEqual

                                                                                                                                                                                      deepEqual: (act: any, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                        method deepInclude

                                                                                                                                                                                        deepInclude: {
                                                                                                                                                                                        (exp: string, inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                        (exp: any[], inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                        };

                                                                                                                                                                                          method deepNestedInclude

                                                                                                                                                                                          deepNestedInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                            method deepNestedPropertyVal

                                                                                                                                                                                            deepNestedPropertyVal: (
                                                                                                                                                                                            obj: object,
                                                                                                                                                                                            prop: string,
                                                                                                                                                                                            val: any,
                                                                                                                                                                                            msg?: string
                                                                                                                                                                                            ) => PromiseLike<void>;

                                                                                                                                                                                              method deepOwnInclude

                                                                                                                                                                                              deepOwnInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                method deepProperty

                                                                                                                                                                                                deepProperty: (obj: Object, prop: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                  method deepPropertyNotVal

                                                                                                                                                                                                  deepPropertyNotVal: (
                                                                                                                                                                                                  obj: Object,
                                                                                                                                                                                                  prop: string,
                                                                                                                                                                                                  val: any,
                                                                                                                                                                                                  msg?: string
                                                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                                                    method deepPropertyVal

                                                                                                                                                                                                    deepPropertyVal: (
                                                                                                                                                                                                    obj: Object,
                                                                                                                                                                                                    prop: string,
                                                                                                                                                                                                    val: any,
                                                                                                                                                                                                    msg?: string
                                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                                      method doesNotChange

                                                                                                                                                                                                      doesNotChange: (
                                                                                                                                                                                                      modifier: Function,
                                                                                                                                                                                                      obj: Object,
                                                                                                                                                                                                      property: string,
                                                                                                                                                                                                      msg?: string
                                                                                                                                                                                                      ) => PromiseLike<void>;

                                                                                                                                                                                                        method doesNotDecrease

                                                                                                                                                                                                        doesNotDecrease: (
                                                                                                                                                                                                        modifier: Function,
                                                                                                                                                                                                        obj: Object,
                                                                                                                                                                                                        property: string,
                                                                                                                                                                                                        msg?: string
                                                                                                                                                                                                        ) => PromiseLike<void>;

                                                                                                                                                                                                          method doesNotHaveAllDeepKeys

                                                                                                                                                                                                          doesNotHaveAllDeepKeys: {
                                                                                                                                                                                                          (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                          (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                          };

                                                                                                                                                                                                            method doesNotHaveAllKeys

                                                                                                                                                                                                            doesNotHaveAllKeys: {
                                                                                                                                                                                                            (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                            (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              method doesNotHaveAnyDeepKeys

                                                                                                                                                                                                              doesNotHaveAnyDeepKeys: {
                                                                                                                                                                                                              (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                              (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method doesNotHaveAnyKeys

                                                                                                                                                                                                                doesNotHaveAnyKeys: {
                                                                                                                                                                                                                (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method doesNotIncrease

                                                                                                                                                                                                                  doesNotIncrease: (
                                                                                                                                                                                                                  modifier: Function,
                                                                                                                                                                                                                  obj: Object,
                                                                                                                                                                                                                  property: string,
                                                                                                                                                                                                                  msg?: string
                                                                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                                                                    method doesNotThrow

                                                                                                                                                                                                                    doesNotThrow: {
                                                                                                                                                                                                                    (fn: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                    (fn: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                    (fn: Function, errType: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                    (fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      method equal

                                                                                                                                                                                                                      equal: (act: any, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                        method exists

                                                                                                                                                                                                                        exists: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                          method fail

                                                                                                                                                                                                                          fail: (
                                                                                                                                                                                                                          actual?: any,
                                                                                                                                                                                                                          expected?: any,
                                                                                                                                                                                                                          msg?: string,
                                                                                                                                                                                                                          operator?: string
                                                                                                                                                                                                                          ) => PromiseLike<void>;

                                                                                                                                                                                                                            method frozen

                                                                                                                                                                                                                            frozen: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                              method hasAllDeepKeys

                                                                                                                                                                                                                              hasAllDeepKeys: {
                                                                                                                                                                                                                              (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                              (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                method hasAllKeys

                                                                                                                                                                                                                                hasAllKeys: {
                                                                                                                                                                                                                                (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  method hasAnyDeepKeys

                                                                                                                                                                                                                                  hasAnyDeepKeys: {
                                                                                                                                                                                                                                  (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                  (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                    method hasAnyKeys

                                                                                                                                                                                                                                    hasAnyKeys: {
                                                                                                                                                                                                                                    (obj: any, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                    (obj: any, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      method ifError

                                                                                                                                                                                                                                      ifError: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                        method include

                                                                                                                                                                                                                                        include: {
                                                                                                                                                                                                                                        (exp: string, inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                        (exp: any[], inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          method includeDeepMembers

                                                                                                                                                                                                                                          includeDeepMembers: (
                                                                                                                                                                                                                                          set1: any[],
                                                                                                                                                                                                                                          set2: any[],
                                                                                                                                                                                                                                          msg?: string
                                                                                                                                                                                                                                          ) => PromiseLike<void>;

                                                                                                                                                                                                                                            method includeDeepOrderedMembers

                                                                                                                                                                                                                                            includeDeepOrderedMembers: (
                                                                                                                                                                                                                                            set1: any[],
                                                                                                                                                                                                                                            set2: any[],
                                                                                                                                                                                                                                            msg?: string
                                                                                                                                                                                                                                            ) => PromiseLike<void>;

                                                                                                                                                                                                                                              method includeMembers

                                                                                                                                                                                                                                              includeMembers: (set1: any[], set2: any[], msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                method includeOrderedMembers

                                                                                                                                                                                                                                                includeOrderedMembers: (
                                                                                                                                                                                                                                                set1: any[],
                                                                                                                                                                                                                                                set2: any[],
                                                                                                                                                                                                                                                msg?: string
                                                                                                                                                                                                                                                ) => PromiseLike<void>;

                                                                                                                                                                                                                                                  method increases

                                                                                                                                                                                                                                                  increases: (
                                                                                                                                                                                                                                                  modifier: Function,
                                                                                                                                                                                                                                                  obj: Object,
                                                                                                                                                                                                                                                  property: string,
                                                                                                                                                                                                                                                  msg?: string
                                                                                                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                                                                                                    method increasesButNotBy

                                                                                                                                                                                                                                                    increasesButNotBy: (
                                                                                                                                                                                                                                                    modifier: Function,
                                                                                                                                                                                                                                                    obj: Object,
                                                                                                                                                                                                                                                    property: string,
                                                                                                                                                                                                                                                    change: number,
                                                                                                                                                                                                                                                    msg?: string
                                                                                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                                                                                      method increasesBy

                                                                                                                                                                                                                                                      increasesBy: (
                                                                                                                                                                                                                                                      modifier: Function,
                                                                                                                                                                                                                                                      obj: Object,
                                                                                                                                                                                                                                                      property: string,
                                                                                                                                                                                                                                                      change: number,
                                                                                                                                                                                                                                                      msg?: string
                                                                                                                                                                                                                                                      ) => PromiseLike<void>;

                                                                                                                                                                                                                                                        method instanceOf

                                                                                                                                                                                                                                                        instanceOf: (val: any, type: Function, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                          method isAbove

                                                                                                                                                                                                                                                          isAbove: (val: number, above: number, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                            method isArray

                                                                                                                                                                                                                                                            isArray: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                              method isAtBelow

                                                                                                                                                                                                                                                              isAtBelow: (val: number, below: number, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                method isAtLeast

                                                                                                                                                                                                                                                                isAtLeast: (val: number, atLeast: number, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                  method isAtMost

                                                                                                                                                                                                                                                                  isAtMost: (val: number, atMost: number, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                    method isBoolean

                                                                                                                                                                                                                                                                    isBoolean: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                      method isDefined

                                                                                                                                                                                                                                                                      isDefined: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                        method isEmpty

                                                                                                                                                                                                                                                                        isEmpty: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                          method isExtensible

                                                                                                                                                                                                                                                                          isExtensible: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                            method isFalse

                                                                                                                                                                                                                                                                            isFalse: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                              method isFinite

                                                                                                                                                                                                                                                                              isFinite: (val: number, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                method isFrozen

                                                                                                                                                                                                                                                                                isFrozen: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                  method isFunction

                                                                                                                                                                                                                                                                                  isFunction: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                    method isNaN

                                                                                                                                                                                                                                                                                    isNaN: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                      method isNotArray

                                                                                                                                                                                                                                                                                      isNotArray: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                        method isNotBoolean

                                                                                                                                                                                                                                                                                        isNotBoolean: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                          method isNotEmpty

                                                                                                                                                                                                                                                                                          isNotEmpty: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                            method isNotExtensible

                                                                                                                                                                                                                                                                                            isNotExtensible: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                              method isNotFalse

                                                                                                                                                                                                                                                                                              isNotFalse: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                method isNotFrozen

                                                                                                                                                                                                                                                                                                isNotFrozen: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                  method isNotFunction

                                                                                                                                                                                                                                                                                                  isNotFunction: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                    method isNotNaN

                                                                                                                                                                                                                                                                                                    isNotNaN: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                      method isNotNull

                                                                                                                                                                                                                                                                                                      isNotNull: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                        method isNotNumber

                                                                                                                                                                                                                                                                                                        isNotNumber: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                          method isNotObject

                                                                                                                                                                                                                                                                                                          isNotObject: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                            method isNotOk

                                                                                                                                                                                                                                                                                                            isNotOk: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                              method isNotSealed

                                                                                                                                                                                                                                                                                                              isNotSealed: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                method isNotString

                                                                                                                                                                                                                                                                                                                isNotString: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                  method isNotTrue

                                                                                                                                                                                                                                                                                                                  isNotTrue: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                    method isNull

                                                                                                                                                                                                                                                                                                                    isNull: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                      method isNumber

                                                                                                                                                                                                                                                                                                                      isNumber: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                        method isObject

                                                                                                                                                                                                                                                                                                                        isObject: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                          method isOk

                                                                                                                                                                                                                                                                                                                          isOk: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                            method isSealed

                                                                                                                                                                                                                                                                                                                            isSealed: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                              method isString

                                                                                                                                                                                                                                                                                                                              isString: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                method isTrue

                                                                                                                                                                                                                                                                                                                                isTrue: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                  method isUndefined

                                                                                                                                                                                                                                                                                                                                  isUndefined: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                    method lengthOf

                                                                                                                                                                                                                                                                                                                                    lengthOf: (exp: any, len: number, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                      method match

                                                                                                                                                                                                                                                                                                                                      match: (exp: any, re: RegExp, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                        method nestedInclude

                                                                                                                                                                                                                                                                                                                                        nestedInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                          method nestedProperty

                                                                                                                                                                                                                                                                                                                                          nestedProperty: (obj: object, prop: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                            method nestedPropertyVal

                                                                                                                                                                                                                                                                                                                                            nestedPropertyVal: (
                                                                                                                                                                                                                                                                                                                                            obj: object,
                                                                                                                                                                                                                                                                                                                                            prop: string,
                                                                                                                                                                                                                                                                                                                                            val: any,
                                                                                                                                                                                                                                                                                                                                            msg?: string
                                                                                                                                                                                                                                                                                                                                            ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                              method notDeepEqual

                                                                                                                                                                                                                                                                                                                                              notDeepEqual: (act: any, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                method notDeepInclude

                                                                                                                                                                                                                                                                                                                                                notDeepInclude: {
                                                                                                                                                                                                                                                                                                                                                (exp: string, inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                (exp: any[], inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                  method notDeepNestedInclude

                                                                                                                                                                                                                                                                                                                                                  notDeepNestedInclude: (
                                                                                                                                                                                                                                                                                                                                                  exp: Object,
                                                                                                                                                                                                                                                                                                                                                  inc: Object,
                                                                                                                                                                                                                                                                                                                                                  msg?: string
                                                                                                                                                                                                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                    method notDeepNestedPropertyVal

                                                                                                                                                                                                                                                                                                                                                    notDeepNestedPropertyVal: (
                                                                                                                                                                                                                                                                                                                                                    obj: object,
                                                                                                                                                                                                                                                                                                                                                    prop: string,
                                                                                                                                                                                                                                                                                                                                                    val: any,
                                                                                                                                                                                                                                                                                                                                                    msg?: string
                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                      method notDeepOwnInclude

                                                                                                                                                                                                                                                                                                                                                      notDeepOwnInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                        method notDeepProperty

                                                                                                                                                                                                                                                                                                                                                        notDeepProperty: (obj: Object, prop: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                          method notEqual

                                                                                                                                                                                                                                                                                                                                                          notEqual: (act: any, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                            method notExists

                                                                                                                                                                                                                                                                                                                                                            notExists: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                              method notFrozen

                                                                                                                                                                                                                                                                                                                                                              notFrozen: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                method notInclude

                                                                                                                                                                                                                                                                                                                                                                notInclude: {
                                                                                                                                                                                                                                                                                                                                                                (exp: string, inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                (exp: any[], inc: any, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                  method notIncludeDeepOrderedMembers

                                                                                                                                                                                                                                                                                                                                                                  notIncludeDeepOrderedMembers: (
                                                                                                                                                                                                                                                                                                                                                                  set1: any[],
                                                                                                                                                                                                                                                                                                                                                                  set2: any[],
                                                                                                                                                                                                                                                                                                                                                                  msg?: string
                                                                                                                                                                                                                                                                                                                                                                  ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                    method notIncludeOrderedMembers

                                                                                                                                                                                                                                                                                                                                                                    notIncludeOrderedMembers: (
                                                                                                                                                                                                                                                                                                                                                                    set1: any[],
                                                                                                                                                                                                                                                                                                                                                                    set2: any[],
                                                                                                                                                                                                                                                                                                                                                                    msg?: string
                                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                      method notInstanceOf

                                                                                                                                                                                                                                                                                                                                                                      notInstanceOf: (val: any, type: Function, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                        method notMatch

                                                                                                                                                                                                                                                                                                                                                                        notMatch: (exp: any, re: RegExp, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                          method notNestedInclude

                                                                                                                                                                                                                                                                                                                                                                          notNestedInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                            method notNestedProperty

                                                                                                                                                                                                                                                                                                                                                                            notNestedProperty: (
                                                                                                                                                                                                                                                                                                                                                                            obj: object,
                                                                                                                                                                                                                                                                                                                                                                            prop: string,
                                                                                                                                                                                                                                                                                                                                                                            msg?: string
                                                                                                                                                                                                                                                                                                                                                                            ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                              method notNestedPropertyVal

                                                                                                                                                                                                                                                                                                                                                                              notNestedPropertyVal: (
                                                                                                                                                                                                                                                                                                                                                                              obj: object,
                                                                                                                                                                                                                                                                                                                                                                              prop: string,
                                                                                                                                                                                                                                                                                                                                                                              val: any,
                                                                                                                                                                                                                                                                                                                                                                              msg?: string
                                                                                                                                                                                                                                                                                                                                                                              ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                method notOk

                                                                                                                                                                                                                                                                                                                                                                                notOk: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                  method notOwnInclude

                                                                                                                                                                                                                                                                                                                                                                                  notOwnInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                    method notProperty

                                                                                                                                                                                                                                                                                                                                                                                    notProperty: (obj: Object, prop: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                      method notSameDeepOrderedMembers

                                                                                                                                                                                                                                                                                                                                                                                      notSameDeepOrderedMembers: (
                                                                                                                                                                                                                                                                                                                                                                                      set1: any[],
                                                                                                                                                                                                                                                                                                                                                                                      set2: any[],
                                                                                                                                                                                                                                                                                                                                                                                      msg?: string
                                                                                                                                                                                                                                                                                                                                                                                      ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                        method notSameOrderedMembers

                                                                                                                                                                                                                                                                                                                                                                                        notSameOrderedMembers: (
                                                                                                                                                                                                                                                                                                                                                                                        set1: any[],
                                                                                                                                                                                                                                                                                                                                                                                        set2: any[],
                                                                                                                                                                                                                                                                                                                                                                                        msg?: string
                                                                                                                                                                                                                                                                                                                                                                                        ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                          method notSealed

                                                                                                                                                                                                                                                                                                                                                                                          notSealed: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                            method notStrictEqual

                                                                                                                                                                                                                                                                                                                                                                                            notStrictEqual: (act: any, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                              method notTypeOf

                                                                                                                                                                                                                                                                                                                                                                                              notTypeOf: (val: any, type: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                method ok

                                                                                                                                                                                                                                                                                                                                                                                                ok: (val: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                  method oneOf

                                                                                                                                                                                                                                                                                                                                                                                                  oneOf: (val: any, list: any[], msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                    method operator

                                                                                                                                                                                                                                                                                                                                                                                                    operator: (
                                                                                                                                                                                                                                                                                                                                                                                                    val: any,
                                                                                                                                                                                                                                                                                                                                                                                                    operator: string,
                                                                                                                                                                                                                                                                                                                                                                                                    val2: any,
                                                                                                                                                                                                                                                                                                                                                                                                    msg?: string
                                                                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                      method ownInclude

                                                                                                                                                                                                                                                                                                                                                                                                      ownInclude: (exp: Object, inc: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                        method property

                                                                                                                                                                                                                                                                                                                                                                                                        property: (obj: Object, prop: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                          method propertyNotVal

                                                                                                                                                                                                                                                                                                                                                                                                          propertyNotVal: (
                                                                                                                                                                                                                                                                                                                                                                                                          obj: Object,
                                                                                                                                                                                                                                                                                                                                                                                                          prop: string,
                                                                                                                                                                                                                                                                                                                                                                                                          val: any,
                                                                                                                                                                                                                                                                                                                                                                                                          msg?: string
                                                                                                                                                                                                                                                                                                                                                                                                          ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                            method propertyVal

                                                                                                                                                                                                                                                                                                                                                                                                            propertyVal: (
                                                                                                                                                                                                                                                                                                                                                                                                            obj: Object,
                                                                                                                                                                                                                                                                                                                                                                                                            prop: string,
                                                                                                                                                                                                                                                                                                                                                                                                            val: any,
                                                                                                                                                                                                                                                                                                                                                                                                            msg?: string
                                                                                                                                                                                                                                                                                                                                                                                                            ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                              method sameDeepMembers

                                                                                                                                                                                                                                                                                                                                                                                                              sameDeepMembers: (set1: any[], set2: any[], msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                method sameDeepOrderedMembers

                                                                                                                                                                                                                                                                                                                                                                                                                sameDeepOrderedMembers: (
                                                                                                                                                                                                                                                                                                                                                                                                                set1: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                set2: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                msg?: string
                                                                                                                                                                                                                                                                                                                                                                                                                ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                  method sameMembers

                                                                                                                                                                                                                                                                                                                                                                                                                  sameMembers: (set1: any[], set2: any[], msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                    method sameOrderedMembers

                                                                                                                                                                                                                                                                                                                                                                                                                    sameOrderedMembers: (
                                                                                                                                                                                                                                                                                                                                                                                                                    set1: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                    set2: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                    msg?: string
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                      method sealed

                                                                                                                                                                                                                                                                                                                                                                                                                      sealed: (obj: Object, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                        method strictEqual

                                                                                                                                                                                                                                                                                                                                                                                                                        strictEqual: (act: any, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                          method throw

                                                                                                                                                                                                                                                                                                                                                                                                                          throw: {
                                                                                                                                                                                                                                                                                                                                                                                                                          (fn: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                          (fn: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                          (fn: Function, errType: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                          (fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            method Throw

                                                                                                                                                                                                                                                                                                                                                                                                                            Throw: {
                                                                                                                                                                                                                                                                                                                                                                                                                            (fn: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            (fn: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            (fn: Function, errType: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            (fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                              method throws

                                                                                                                                                                                                                                                                                                                                                                                                                              throws: {
                                                                                                                                                                                                                                                                                                                                                                                                                              (fn: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                              (fn: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                              (fn: Function, errType: Function, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                              (fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                method typeOf

                                                                                                                                                                                                                                                                                                                                                                                                                                typeOf: (val: any, type: string, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PromisedAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PromisedAssertion extends Eventually, PromiseLike<any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PromisedCloseTo

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PromisedCloseTo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedDeep

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedDeep {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property eq

                                                                                                                                                                                                                                                                                                                                                                                                                                          eq: PromisedEqual;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property equal

                                                                                                                                                                                                                                                                                                                                                                                                                                            equal: PromisedEqual;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property equals

                                                                                                                                                                                                                                                                                                                                                                                                                                              equals: PromisedEqual;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                include: PromisedInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property members

                                                                                                                                                                                                                                                                                                                                                                                                                                                  members: PromisedMembers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                    ordered: PromisedOrdered;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property property

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property: PromisedProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedEqual {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PromisedInclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PromisedInclude {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property all

                                                                                                                                                                                                                                                                                                                                                                                                                                                              all: PromisedKeyFilter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property any

                                                                                                                                                                                                                                                                                                                                                                                                                                                                any: PromisedKeyFilter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property deep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  deep: PromisedDeep;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keys: PromisedKeys;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property members

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      members: PromisedMembers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ordered: PromisedOrdered;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (value: Object, message?: string): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (value: string, message?: string): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (value: number, message?: string): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedInstanceOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedInstanceOf {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (constructor: Object, message?: string): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PromisedKeyFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PromisedKeyFilter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property keys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keys: PromisedKeys;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedKeys {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (keys: any[]): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (keys: Object): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedLanguageChains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedLanguageChains {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property and

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  and: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    at: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property be

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      be: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property been

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        been: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property but

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          but: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property does

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            does: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property eventually

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              eventually: Eventually;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                has: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property have

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  have: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property is

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    is: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property of

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      of: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property same

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        same: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property that

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          that: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            to: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property which

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              which: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property with

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                with: PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PromisedLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PromisedLength extends PromisedLanguageChains, PromisedNumericComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PromisedMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PromisedMatch {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (regexp: RegExp | string, message?: string): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PromisedMembers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PromisedMembers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PromisedNested

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PromisedNested {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property include

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                include: PromisedInclude;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property members

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  members: PromisedMembers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property: PromisedProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PromisedNumberComparer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PromisedNumberComparer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (value: number, message?: string): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PromisedNumericComparison

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PromisedNumericComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property above

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            above: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property below

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              below: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property greaterThan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                greaterThan: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property gt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  gt: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property gte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gte: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property least

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      least: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property lessThan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lessThan: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lt: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property lte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lte: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property most

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              most: PromisedNumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method within

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                within: (start: number, finish: number, message?: string) => PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PromisedOrdered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PromisedOrdered {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property members

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    members: PromisedMembers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PromisedOwnProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PromisedOwnProperty {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PromisedOwnPropertyDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PromisedOwnPropertyDescriptor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedProperty {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PromisedPropertyChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PromisedPropertyChange {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedRespondTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedRespondTo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PromisedSatisfy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PromisedSatisfy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedThrow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PromisedThrow {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (): PromisedAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedTypeComparison

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PromisedTypeComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property instanceof

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          instanceof: PromisedInstanceOf;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property instanceOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            instanceOf: PromisedInstanceOf;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace chai-as-promised

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'chai-as-promised' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable chaiAsPromised

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const chaiAsPromised: ChaiAsPromised;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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-as-promised.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/chai-as-promised)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <a href="https://www.jsdocs.io/package/@types/chai-as-promised"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>