@types/chai-as-promised

Version 7.1.8
Published 5 months ago
26.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

Namespaces

namespace Chai

namespace Chai {}

interface Assert

interface Assert {}

property eventually

eventually: PromisedAssert;

method becomes

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

method doesNotBecome

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

method isFulfilled

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

method isRejected

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

method notify

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

interface Assertion

interface Assertion extends LanguageChains, NumericComparison, TypeComparison {}

property eventually

eventually: PromisedAssertion;

property fulfilled

fulfilled: PromisedAssertion;

property rejected

rejected: PromisedAssertion;

property rejectedWith

rejectedWith: PromisedThrow;

method become

become: (expected: any) => PromisedAssertion;

method notify

notify: (fn: Function) => PromisedAssertion;

interface Eventually

interface Eventually
    extends PromisedLanguageChains,
        PromisedNumericComparison,
        PromisedTypeComparison {}

property a

a: PromisedTypeComparison;

property all

all: PromisedKeyFilter;

property an

an: PromisedTypeComparison;

property any

any: PromisedKeyFilter;

property approximately

approximately: PromisedCloseTo;

property arguments

arguments: PromisedAssertion;

property Arguments

Arguments: PromisedAssertion;

property change

change: PromisedPropertyChange;

property changes

changes: PromisedPropertyChange;

property closeTo

closeTo: PromisedCloseTo;

property contain

contain: PromisedInclude;

property decrease

decrease: PromisedPropertyChange;

property decreases

decreases: PromisedPropertyChange;

property deep

deep: PromisedDeep;

property empty

empty: PromisedAssertion;

property eq

eq: PromisedEqual;

property eql

eql: PromisedEqual;

property eqls

eqls: PromisedEqual;

property equal

equal: PromisedEqual;

property equals

equals: PromisedEqual;

property exist

exist: PromisedAssertion;

property extensible

extensible: PromisedAssertion;

property false

false: PromisedAssertion;

property frozen

frozen: PromisedAssertion;

property fulfilled

fulfilled: PromisedAssertion;

property haveOwnProperty

haveOwnProperty: PromisedOwnProperty;

property haveOwnPropertyDescriptor

haveOwnPropertyDescriptor: PromisedOwnPropertyDescriptor;

property include

include: PromisedInclude;

property increase

increase: PromisedPropertyChange;

property increases

increases: PromisedPropertyChange;

property itself

itself: PromisedAssertion;

property keys

keys: PromisedKeys;

property length

length: PromisedLength;

property lengthOf

lengthOf: PromisedLength;

property match

match: PromisedMatch;

property matches

matches: PromisedMatch;

property members

members: PromisedMembers;

property NaN

NaN: PromisedAssertion;

property nested

nested: PromisedNested;

property not

not: PromisedAssertion;

property null

null: PromisedAssertion;

property ok

ok: PromisedAssertion;

property ordered

ordered: PromisedOrdered;

property ownProperty

ownProperty: PromisedOwnProperty;

property ownPropertyDescriptor

ownPropertyDescriptor: PromisedOwnPropertyDescriptor;

property property

property: PromisedProperty;

property rejected

rejected: PromisedAssertion;

property rejectedWith

rejectedWith: PromisedThrow;

property respondsTo

respondsTo: PromisedRespondTo;

property respondTo

respondTo: PromisedRespondTo;

property satisfies

satisfies: PromisedSatisfy;

property satisfy

satisfy: PromisedSatisfy;

property sealed

sealed: PromisedAssertion;

property throw

throw: PromisedThrow;

property Throw

Throw: PromisedThrow;

property throws

throws: PromisedThrow;

property true

true: PromisedAssertion;

property undefined

undefined: PromisedAssertion;

method become

become: (expected: any) => PromisedAssertion;

method key

key: (string: string) => PromisedAssertion;

method notify

notify: (fn: Function) => PromisedAssertion;

method oneOf

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

method string

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

interface PromisedAssert

interface PromisedAssert {}

method approximately

approximately: (
    act: 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 PromisedDeep

interface PromisedDeep {}

property eq

eq: PromisedEqual;

property equal

equal: PromisedEqual;

property equals

equals: PromisedEqual;

property include

include: PromisedInclude;

property members

members: PromisedMembers;

property ordered

ordered: PromisedOrdered;

property property

property: PromisedProperty;

interface PromisedEqual

interface PromisedEqual {}

call signature

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

interface PromisedInclude

interface PromisedInclude {}

property all

all: PromisedKeyFilter;

property any

any: PromisedKeyFilter;

property deep

deep: PromisedDeep;

property keys

keys: PromisedKeys;

property members

members: PromisedMembers;

property ordered

ordered: PromisedOrdered;

call signature

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

call signature

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

call signature

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

interface PromisedInstanceOf

interface PromisedInstanceOf {}

call signature

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

interface PromisedKeyFilter

interface PromisedKeyFilter {}

property keys

keys: PromisedKeys;

interface PromisedKeys

interface PromisedKeys {}

call signature

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

call signature

(keys: any[]): PromisedAssertion;

call signature

(keys: Object): PromisedAssertion;

interface PromisedLanguageChains

interface PromisedLanguageChains {}

property and

and: PromisedAssertion;

property at

at: PromisedAssertion;

property be

be: PromisedAssertion;

property been

been: PromisedAssertion;

property but

but: PromisedAssertion;

property does

does: PromisedAssertion;

property eventually

eventually: Eventually;

property has

has: PromisedAssertion;

property have

have: PromisedAssertion;

property is

is: PromisedAssertion;

property of

of: PromisedAssertion;

property same

same: PromisedAssertion;

property that

that: PromisedAssertion;

property to

to: PromisedAssertion;

property which

which: PromisedAssertion;

property with

with: PromisedAssertion;

interface PromisedLength

interface PromisedLength extends PromisedLanguageChains, PromisedNumericComparison {}

call signature

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

interface PromisedMatch

interface PromisedMatch {}

call signature

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

interface PromisedMembers

interface PromisedMembers {}

call signature

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

interface PromisedNested

interface PromisedNested {}

property include

include: PromisedInclude;

property members

members: PromisedMembers;

property property

property: PromisedProperty;

interface PromisedNumberComparer

interface PromisedNumberComparer {}

call signature

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

interface PromisedNumericComparison

interface PromisedNumericComparison {}

property above

above: PromisedNumberComparer;

property below

below: PromisedNumberComparer;

property greaterThan

greaterThan: PromisedNumberComparer;

property gt

gt: PromisedNumberComparer;

property gte

gte: PromisedNumberComparer;

property least

least: PromisedNumberComparer;

property lessThan

lessThan: PromisedNumberComparer;

property lt

lt: PromisedNumberComparer;

property lte

lte: PromisedNumberComparer;

property most

most: PromisedNumberComparer;

method within

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

interface PromisedOrdered

interface PromisedOrdered {}

property members

members: PromisedMembers;

interface PromisedOwnProperty

interface PromisedOwnProperty {}

call signature

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

interface PromisedOwnPropertyDescriptor

interface PromisedOwnPropertyDescriptor {}

call signature

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

call signature

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

interface PromisedProperty

interface PromisedProperty {}

call signature

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

interface PromisedPropertyChange

interface PromisedPropertyChange {}

call signature

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

interface PromisedRespondTo

interface PromisedRespondTo {}

call signature

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

interface PromisedSatisfy

interface PromisedSatisfy {}

call signature

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

interface PromisedThrow

interface PromisedThrow {}

call signature

(): PromisedAssertion;

call signature

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

call signature

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

interface PromisedTypeComparison

interface PromisedTypeComparison {}

property instanceof

instanceof: PromisedInstanceOf;

property instanceOf

instanceOf: PromisedInstanceOf;

call signature

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

namespace chai-as-promised

module 'chai-as-promised' {}

variable chaiAsPromised

const chaiAsPromised: ChaiAsPromised;

Package Files (1)

index.d.ts

Dependencies (1)

@types/chai

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto 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>

Updated 5 months ago.
Package analyzed in 5999 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/chai-as-promised

Install

Overview

Index

Namespaces

Namespaces

namespace Chai

interface Assert

property eventually

method becomes

method doesNotBecome

method isFulfilled

method isRejected

method notify

interface Assertion

property eventually

property fulfilled

property rejected

property rejectedWith

method become

method notify

interface Eventually

property a

property all

property an

property any

property approximately

property arguments

property Arguments

property change

property changes

property closeTo

property contain

property decrease

property decreases

property deep

property empty

property eq

property eql

property eqls

property equal

property equals

property exist

property extensible

property false

property frozen

property fulfilled

property haveOwnProperty

property haveOwnPropertyDescriptor

property include

property increase

property increases

property itself

property keys

property length

property lengthOf

property match

property matches

property members

property NaN

property nested

property not

property null

property ok

property ordered

property ownProperty

property ownPropertyDescriptor

property property

property rejected

property rejectedWith

property respondsTo

property respondTo

property satisfies

property satisfy

property sealed

property throw

property Throw

property throws

property true

property undefined