// Type definitions for chai-as-promised
// Project: https://github.com/domenic/chai-as-promised/
// Definitions by: jt000 <https://github.com/jt000>, Yuki Kokubun <https://github.com/Kuniwak>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare module 'chai-as-promised' {
function chaiAsPromised(chai: any, utils: any): void;
namespace chaiAsPromised {
}
export = chaiAsPromised;
}
// tslint:disable:no-namespace ban-types member-ordering
declare namespace Chai {
// For BDD API
interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
eventually: PromisedAssertion;
fulfilled: PromisedAssertion;
become(expected: any): PromisedAssertion;
rejected(): PromisedAssertion;
rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
notify(fn: Function): PromisedAssertion;
}
// Eventually does not have .then(), but PromisedAssertion have.
interface Eventually extends PromisedLanguageChains, PromisedNumericComparison, PromisedTypeComparison {
// From chai-as-promised
become(expected: PromiseLike<any>): PromisedAssertion;
fulfilled: PromisedAssertion;
rejected: () => PromisedAssertion;
rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
notify(fn: Function): PromisedAssertion;
// From chai
not: PromisedAssertion;
deep: PromisedDeep;
all: PromisedKeyFilter;
a: PromisedTypeComparison;
an: PromisedTypeComparison;
include: PromisedInclude;
contain: PromisedInclude;
ok: PromisedAssertion;
true: () => PromisedAssertion;
false: () => PromisedAssertion;
null: PromisedAssertion;
undefined: PromisedAssertion;
exist: PromisedAssertion;
empty: PromisedAssertion;
arguments: PromisedAssertion;
Arguments: PromisedAssertion;
equal: PromisedEqual;
equals: PromisedEqual;
eq: PromisedEqual;
eql: PromisedEqual;
eqls: PromisedEqual;
property: PromisedProperty;
ownProperty: PromisedOwnProperty;
haveOwnProperty: PromisedOwnProperty;
length: PromisedLength;
lengthOf: PromisedLength;
match(regexp: RegExp | string, message?: string): PromisedAssertion;
string(string: string, message?: string): PromisedAssertion;
keys: PromisedKeys;
key(string: string): PromisedAssertion;
throw: PromisedThrow;
throws: PromisedThrow;
Throw: PromisedThrow;
respondTo(method: string, message?: string): PromisedAssertion;
itself: PromisedAssertion;
satisfy(matcher: Function, message?: string): PromisedAssertion;
closeTo(expected: number, delta: number, message?: string): PromisedAssertion;
members: PromisedMembers;
}
interface PromisedAssertion extends Eventually, PromiseLike<any> {}
interface PromisedLanguageChains {
eventually: Eventually;
// From chai
to: PromisedAssertion;
be: PromisedAssertion;
been: PromisedAssertion;
is: PromisedAssertion;
that: PromisedAssertion;
which: PromisedAssertion;
and: PromisedAssertion;
has: PromisedAssertion;
have: PromisedAssertion;
with: PromisedAssertion;
at: PromisedAssertion;
of: PromisedAssertion;
same: PromisedAssertion;
}
interface PromisedNumericComparison {
above: PromisedNumberComparer;
gt: PromisedNumberComparer;
greaterThan: PromisedNumberComparer;
least: PromisedNumberComparer;
gte: PromisedNumberComparer;
below: PromisedNumberComparer;
lt: PromisedNumberComparer;
lessThan: PromisedNumberComparer;
most: PromisedNumberComparer;
lte: PromisedNumberComparer;
within(start: number, finish: number, message?: string): PromisedAssertion;
}
type PromisedNumberComparer = (value: number, message?: string) => PromisedAssertion;
interface PromisedTypeComparison {
(type: string, message?: string): PromisedAssertion;
instanceof: PromisedInstanceOf;
instanceOf: PromisedInstanceOf;
}
type PromisedInstanceOf = (constructor: Object, message?: string) => PromisedAssertion;
interface PromisedDeep {
equal: PromisedEqual;
include: PromisedInclude;
property: PromisedProperty;
}
interface PromisedKeyFilter {
keys: PromisedKeys;
}
type PromisedEqual = (value: any, message?: string) => PromisedAssertion;
type PromisedProperty = (name: string, value?: any, message?: string) => PromisedAssertion;
type PromisedOwnProperty = (name: string, message?: string) => PromisedAssertion;
interface PromisedLength extends PromisedLanguageChains, PromisedNumericComparison {
(length: number, message?: string): PromisedAssertion;
}
interface PromisedInclude {
(value: Object | string | number, message?: string): PromisedAssertion;
keys: PromisedKeys;
members: PromisedMembers;
all: PromisedKeyFilter;
}
interface PromisedKeys {
(...keys: string[]): PromisedAssertion;
(keys: any[]): PromisedAssertion;
}
interface PromisedThrow {
(): PromisedAssertion;
(expected: string | RegExp, message?: string): PromisedAssertion;
(constructor: Error | Function, expected?: string | RegExp, message?: string): PromisedAssertion;
}
type PromisedMembers = (set: any[], message?: string) => PromisedAssertion;
// For Assert API
interface Assert {
eventually: PromisedAssert;
isFulfilled(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
becomes(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
doesNotBecome(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
isRejected(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
isRejected(promise: PromiseLike<any>, expected: any | RegExp, message?: string): PromiseLike<void>;
notify(fn: Function): PromiseLike<void>;
}
export interface PromisedAssert {
fail(actual?: any, expected?: any, msg?: string, operator?: string): PromiseLike<void>;
ok(val: any, msg?: string): PromiseLike<void>;
notOk(val: any, msg?: string): PromiseLike<void>;
equal(act: any, exp: any, msg?: string): PromiseLike<void>;
notEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
strictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
notStrictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
deepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
notDeepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
isTrue(val: any, msg?: string): PromiseLike<void>;
isFalse(val: any, msg?: string): PromiseLike<void>;
isNull(val: any, msg?: string): PromiseLike<void>;
isNotNull(val: any, msg?: string): PromiseLike<void>;
isUndefined(val: any, msg?: string): PromiseLike<void>;
isDefined(val: any, msg?: string): PromiseLike<void>;
isFunction(val: any, msg?: string): PromiseLike<void>;
isNotFunction(val: any, msg?: string): PromiseLike<void>;
isObject(val: any, msg?: string): PromiseLike<void>;
isNotObject(val: any, msg?: string): PromiseLike<void>;
isArray(val: any, msg?: string): PromiseLike<void>;
isNotArray(val: any, msg?: string): PromiseLike<void>;
isString(val: any, msg?: string): PromiseLike<void>;
isNotString(val: any, msg?: string): PromiseLike<void>;
isNumber(val: any, msg?: string): PromiseLike<void>;
isNotNumber(val: any, msg?: string): PromiseLike<void>;
isBoolean(val: any, msg?: string): PromiseLike<void>;
isNotBoolean(val: any, msg?: string): PromiseLike<void>;
typeOf(val: any, type: string, msg?: string): PromiseLike<void>;
notTypeOf(val: any, type: string, msg?: string): PromiseLike<void>;
instanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
notInstanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
include(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
notInclude(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
match(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
notMatch(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
property(obj: Object, prop: string, msg?: string): PromiseLike<void>;
notProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
deepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
notDeepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
propertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
propertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
lengthOf(exp: any, len: number, msg?: string): PromiseLike<void>;
// alias frenzy
throw(fn: Function, msg?: string): PromiseLike<void>;
throw(fn: Function, regExp: RegExp): PromiseLike<void>;
throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
throws(fn: Function, msg?: string): PromiseLike<void>;
throws(fn: Function, regExp: RegExp): PromiseLike<void>;
throws(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
throws(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
Throw(fn: Function, msg?: string): PromiseLike<void>;
Throw(fn: Function, regExp: RegExp): PromiseLike<void>;
Throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
Throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
doesNotThrow(fn: Function, msg?: string): PromiseLike<void>;
doesNotThrow(fn: Function, regExp: RegExp): PromiseLike<void>;
doesNotThrow(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
doesNotThrow(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
operator(val: any, operator: string, val2: any, msg?: string): PromiseLike<void>;
closeTo(act: number, exp: number, delta: number, msg?: string): PromiseLike<void>;
sameMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
includeMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
ifError(val: any, msg?: string): PromiseLike<void>;
}
}
