@types/chai-as-promised

  • Version 8.0.2
  • Published
  • 28.1 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

Variables

variable chaiAsPromised

const chaiAsPromised: ChaiAsPromised;

    Namespaces

    namespace global

    namespace global {}

      namespace global.Chai

      namespace global.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 containSubset

                                                            containSubset: PromisedContainSubset;

                                                              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: PromiseLike<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: PromiseLike<number>,
                                                                                                                                                                                exp: number,
                                                                                                                                                                                delta: number,
                                                                                                                                                                                msg?: string
                                                                                                                                                                                ) => PromiseLike<void>;

                                                                                                                                                                                  method containsAllDeepKeys

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

                                                                                                                                                                                    method containsAllKeys

                                                                                                                                                                                    containsAllKeys: {
                                                                                                                                                                                    (obj: PromiseLike<any>, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                    (obj: PromiseLike<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: PromiseLike<any>, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                              method deepInclude

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

                                                                                                                                                                                                method deepNestedInclude

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

                                                                                                                                                                                                  method deepNestedPropertyVal

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

                                                                                                                                                                                                    method deepOwnInclude

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

                                                                                                                                                                                                      method deepProperty

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

                                                                                                                                                                                                        method deepPropertyNotVal

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

                                                                                                                                                                                                          method deepPropertyVal

                                                                                                                                                                                                          deepPropertyVal: (
                                                                                                                                                                                                          obj: PromiseLike<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: PromiseLike<any>, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                (obj: PromiseLike<any>, keys: object, msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method doesNotHaveAllKeys

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

                                                                                                                                                                                                                    method doesNotHaveAnyDeepKeys

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

                                                                                                                                                                                                                      method doesNotHaveAnyKeys

                                                                                                                                                                                                                      doesNotHaveAnyKeys: {
                                                                                                                                                                                                                      (obj: PromiseLike<any>, keys: any[], msg?: string): PromiseLike<void>;
                                                                                                                                                                                                                      (obj: PromiseLike<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: PromiseLike<any>, exp: any, msg?: string) => PromiseLike<void>;

                                                                                                                                                                                                                              method exists

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

                                                                                                                                                                                                                                method fail

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

                                                                                                                                                                                                                                  method frozen

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

                                                                                                                                                                                                                                    method hasAllDeepKeys

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

                                                                                                                                                                                                                                      method hasAllKeys

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

                                                                                                                                                                                                                                        method hasAnyDeepKeys

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

                                                                                                                                                                                                                                          method hasAnyKeys

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

                                                                                                                                                                                                                                            method ifError

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

                                                                                                                                                                                                                                              method include

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

                                                                                                                                                                                                                                                method includeDeepMembers

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

                                                                                                                                                                                                                                                  method includeDeepOrderedMembers

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

                                                                                                                                                                                                                                                    method includeMembers

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

                                                                                                                                                                                                                                                      method includeOrderedMembers

                                                                                                                                                                                                                                                      includeOrderedMembers: (
                                                                                                                                                                                                                                                      set1: PromiseLike<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: PromiseLike<any>,
                                                                                                                                                                                                                                                              type: Function,
                                                                                                                                                                                                                                                              msg?: string
                                                                                                                                                                                                                                                              ) => PromiseLike<void>;

                                                                                                                                                                                                                                                                method isAbove

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

                                                                                                                                                                                                                                                                  method isArray

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

                                                                                                                                                                                                                                                                    method isAtBelow

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

                                                                                                                                                                                                                                                                      method isAtLeast

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

                                                                                                                                                                                                                                                                        method isAtMost

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

                                                                                                                                                                                                                                                                          method isBoolean

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

                                                                                                                                                                                                                                                                            method isDefined

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

                                                                                                                                                                                                                                                                              method isEmpty

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

                                                                                                                                                                                                                                                                                method isExtensible

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

                                                                                                                                                                                                                                                                                  method isFalse

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

                                                                                                                                                                                                                                                                                    method isFinite

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

                                                                                                                                                                                                                                                                                      method isFrozen

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

                                                                                                                                                                                                                                                                                        method isFunction

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

                                                                                                                                                                                                                                                                                          method isNaN

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

                                                                                                                                                                                                                                                                                            method isNotArray

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

                                                                                                                                                                                                                                                                                              method isNotBoolean

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

                                                                                                                                                                                                                                                                                                method isNotEmpty

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

                                                                                                                                                                                                                                                                                                  method isNotExtensible

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

                                                                                                                                                                                                                                                                                                    method isNotFalse

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

                                                                                                                                                                                                                                                                                                      method isNotFrozen

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

                                                                                                                                                                                                                                                                                                        method isNotFunction

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

                                                                                                                                                                                                                                                                                                          method isNotNaN

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

                                                                                                                                                                                                                                                                                                            method isNotNull

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

                                                                                                                                                                                                                                                                                                              method isNotNumber

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

                                                                                                                                                                                                                                                                                                                method isNotObject

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

                                                                                                                                                                                                                                                                                                                  method isNotOk

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

                                                                                                                                                                                                                                                                                                                    method isNotSealed

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

                                                                                                                                                                                                                                                                                                                      method isNotString

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

                                                                                                                                                                                                                                                                                                                        method isNotTrue

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

                                                                                                                                                                                                                                                                                                                          method isNull

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

                                                                                                                                                                                                                                                                                                                            method isNumber

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

                                                                                                                                                                                                                                                                                                                              method isObject

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

                                                                                                                                                                                                                                                                                                                                method isOk

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

                                                                                                                                                                                                                                                                                                                                  method isSealed

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

                                                                                                                                                                                                                                                                                                                                    method isString

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

                                                                                                                                                                                                                                                                                                                                      method isTrue

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

                                                                                                                                                                                                                                                                                                                                        method isUndefined

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

                                                                                                                                                                                                                                                                                                                                          method lengthOf

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

                                                                                                                                                                                                                                                                                                                                            method match

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

                                                                                                                                                                                                                                                                                                                                              method nestedInclude

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

                                                                                                                                                                                                                                                                                                                                                method nestedProperty

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

                                                                                                                                                                                                                                                                                                                                                  method nestedPropertyVal

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

                                                                                                                                                                                                                                                                                                                                                    method notDeepEqual

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

                                                                                                                                                                                                                                                                                                                                                      method notDeepInclude

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

                                                                                                                                                                                                                                                                                                                                                        method notDeepNestedInclude

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

                                                                                                                                                                                                                                                                                                                                                          method notDeepNestedPropertyVal

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

                                                                                                                                                                                                                                                                                                                                                            method notDeepOwnInclude

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

                                                                                                                                                                                                                                                                                                                                                              method notDeepProperty

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

                                                                                                                                                                                                                                                                                                                                                                method notEqual

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

                                                                                                                                                                                                                                                                                                                                                                  method notExists

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

                                                                                                                                                                                                                                                                                                                                                                    method notFrozen

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

                                                                                                                                                                                                                                                                                                                                                                      method notInclude

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

                                                                                                                                                                                                                                                                                                                                                                        method notIncludeDeepOrderedMembers

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

                                                                                                                                                                                                                                                                                                                                                                          method notIncludeOrderedMembers

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

                                                                                                                                                                                                                                                                                                                                                                            method notInstanceOf

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

                                                                                                                                                                                                                                                                                                                                                                              method notMatch

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

                                                                                                                                                                                                                                                                                                                                                                                method notNestedInclude

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

                                                                                                                                                                                                                                                                                                                                                                                  method notNestedProperty

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

                                                                                                                                                                                                                                                                                                                                                                                    method notNestedPropertyVal

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

                                                                                                                                                                                                                                                                                                                                                                                      method notOk

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

                                                                                                                                                                                                                                                                                                                                                                                        method notOwnInclude

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

                                                                                                                                                                                                                                                                                                                                                                                          method notProperty

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

                                                                                                                                                                                                                                                                                                                                                                                            method notSameDeepOrderedMembers

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

                                                                                                                                                                                                                                                                                                                                                                                              method notSameOrderedMembers

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

                                                                                                                                                                                                                                                                                                                                                                                                method notSealed

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

                                                                                                                                                                                                                                                                                                                                                                                                  method notStrictEqual

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

                                                                                                                                                                                                                                                                                                                                                                                                    method notTypeOf

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

                                                                                                                                                                                                                                                                                                                                                                                                      method ok

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

                                                                                                                                                                                                                                                                                                                                                                                                        method oneOf

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

                                                                                                                                                                                                                                                                                                                                                                                                          method operator

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

                                                                                                                                                                                                                                                                                                                                                                                                            method ownInclude

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

                                                                                                                                                                                                                                                                                                                                                                                                              method property

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

                                                                                                                                                                                                                                                                                                                                                                                                                method propertyNotVal

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

                                                                                                                                                                                                                                                                                                                                                                                                                  method propertyVal

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

                                                                                                                                                                                                                                                                                                                                                                                                                    method sameDeepMembers

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

                                                                                                                                                                                                                                                                                                                                                                                                                      method sameDeepOrderedMembers

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

                                                                                                                                                                                                                                                                                                                                                                                                                        method sameMembers

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

                                                                                                                                                                                                                                                                                                                                                                                                                          method sameOrderedMembers

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

                                                                                                                                                                                                                                                                                                                                                                                                                            method sealed

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

                                                                                                                                                                                                                                                                                                                                                                                                                              method strictEqual

                                                                                                                                                                                                                                                                                                                                                                                                                              strictEqual: (
                                                                                                                                                                                                                                                                                                                                                                                                                              act: PromiseLike<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: PromiseLike<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 PromisedContainSubset

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PromisedContainSubset {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                (value: any): 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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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>