530 строки
16 KiB
TypeScript
530 строки
16 KiB
TypeScript
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/typed-typings/npm-assertion-error/105841317bd2bdd5d110bfb763e49e482a77230d/main.d.ts
|
|
declare module '~chai~assertion-error' {
|
|
// Type definitions for assertion-error 1.0.0
|
|
// Project: https://github.com/chaijs/assertion-error
|
|
// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
|
|
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
|
|
|
export class AssertionError implements Error {
|
|
constructor(message: string, props?: any, ssf?: Function);
|
|
public name: string;
|
|
public message: string;
|
|
public showDiff: boolean;
|
|
public stack: string;
|
|
|
|
/**
|
|
* Allow errors to be converted to JSON for static transfer.
|
|
*
|
|
* @param {Boolean} include stack (default: `true`)
|
|
* @return {Object} object that can be `JSON.stringify`
|
|
*/
|
|
public toJSON(stack: boolean): Object;
|
|
}
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Assert.d.ts
|
|
declare module '~chai/lib/Assert' {
|
|
export interface AssertStatic extends Assert {
|
|
}
|
|
|
|
export interface Assert {
|
|
/**
|
|
* @param expression Expression to test for truthiness.
|
|
* @param message Message to display on error.
|
|
*/
|
|
(expression: any, message?: string): void;
|
|
(expression: any, messageCallback: () => string): void;
|
|
|
|
fail(actual?: any, expected?: any, msg?: string, operator?: string): void;
|
|
|
|
ok(val: any, msg?: string): void;
|
|
isOk(val: any, msg?: string): void;
|
|
notOk(val: any, msg?: string): void;
|
|
isNotOk(val: any, msg?: string): void;
|
|
|
|
equal(act: any, exp: any, msg?: string): void;
|
|
notEqual(act: any, exp: any, msg?: string): void;
|
|
|
|
strictEqual(act: any, exp: any, msg?: string): void;
|
|
notStrictEqual(act: any, exp: any, msg?: string): void;
|
|
|
|
deepEqual(act: any, exp: any, msg?: string): void;
|
|
notDeepEqual(act: any, exp: any, msg?: string): void;
|
|
|
|
isTrue(val: any, msg?: string): void;
|
|
isFalse(val: any, msg?: string): void;
|
|
|
|
isNotTrue(val: any, msg?: string): void;
|
|
isNotFalse(val: any, msg?: string): void;
|
|
|
|
isNull(val: any, msg?: string): void;
|
|
isNotNull(val: any, msg?: string): void;
|
|
|
|
isUndefined(val: any, msg?: string): void;
|
|
isDefined(val: any, msg?: string): void;
|
|
|
|
isNaN(val: any, msg?: string): void;
|
|
isNotNaN(val: any, msg?: string): void;
|
|
|
|
isAbove(val: number, abv: number, msg?: string): void;
|
|
isBelow(val: number, blw: number, msg?: string): void;
|
|
|
|
isAtLeast(val: number, atlst: number, msg?: string): void;
|
|
isAtMost(val: number, atmst: number, msg?: string): void;
|
|
|
|
isFunction(val: any, msg?: string): void;
|
|
isNotFunction(val: any, msg?: string): void;
|
|
|
|
isObject(val: any, msg?: string): void;
|
|
isNotObject(val: any, msg?: string): void;
|
|
|
|
isArray(val: any, msg?: string): void;
|
|
isNotArray(val: any, msg?: string): void;
|
|
|
|
isString(val: any, msg?: string): void;
|
|
isNotString(val: any, msg?: string): void;
|
|
|
|
isNumber(val: any, msg?: string): void;
|
|
isNotNumber(val: any, msg?: string): void;
|
|
|
|
isBoolean(val: any, msg?: string): void;
|
|
isNotBoolean(val: any, msg?: string): void;
|
|
|
|
typeOf(val: any, type: string, msg?: string): void;
|
|
notTypeOf(val: any, type: string, msg?: string): void;
|
|
|
|
instanceOf(val: any, type: Function, msg?: string): void;
|
|
notInstanceOf(val: any, type: Function, msg?: string): void;
|
|
|
|
include(exp: string, inc: any, msg?: string): void;
|
|
include(exp: any[], inc: any, msg?: string): void;
|
|
include(exp: Object, inc: Object, msg?: string): void;
|
|
|
|
notInclude(exp: string, inc: any, msg?: string): void;
|
|
notInclude(exp: any[], inc: any, msg?: string): void;
|
|
|
|
match(exp: any, re: RegExp, msg?: string): void;
|
|
notMatch(exp: any, re: RegExp, msg?: string): void;
|
|
|
|
property(obj: Object, prop: string, msg?: string): void;
|
|
notProperty(obj: Object, prop: string, msg?: string): void;
|
|
deepProperty(obj: Object, prop: string, msg?: string): void;
|
|
notDeepProperty(obj: Object, prop: string, msg?: string): void;
|
|
|
|
propertyVal(obj: Object, prop: string, val: any, msg?: string): void;
|
|
propertyNotVal(obj: Object, prop: string, val: any, msg?: string): void;
|
|
|
|
deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): void;
|
|
deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): void;
|
|
|
|
lengthOf(exp: any, len: number, msg?: string): void;
|
|
|
|
throw(fn: Function, msg?: string): void;
|
|
throw(fn: Function, regExp: RegExp): void;
|
|
throw(fn: Function, errType: Function, msg?: string): void;
|
|
throw(fn: Function, errType: Function, regExp: RegExp): void;
|
|
|
|
throws(fn: Function, msg?: string): void;
|
|
throws(fn: Function, regExp: RegExp): void;
|
|
throws(fn: Function, errType: Function, msg?: string): void;
|
|
throws(fn: Function, errType: Function, regExp: RegExp): void;
|
|
|
|
Throw(fn: Function, msg?: string): void;
|
|
Throw(fn: Function, regExp: RegExp): void;
|
|
Throw(fn: Function, errType: Function, msg?: string): void;
|
|
Throw(fn: Function, errType: Function, regExp: RegExp): void;
|
|
|
|
doesNotThrow(fn: Function, msg?: string): void;
|
|
doesNotThrow(fn: Function, regExp: RegExp): void;
|
|
doesNotThrow(fn: Function, errType: Function, msg?: string): void;
|
|
doesNotThrow(fn: Function, errType: Function, regExp: RegExp): void;
|
|
|
|
operator(val: any, operator: string, val2: any, msg?: string): void;
|
|
closeTo(act: number, exp: number, delta: number, msg?: string): void;
|
|
approximately(act: number, exp: number, delta: number, msg?: string): void;
|
|
|
|
sameMembers(set1: any[], set2: any[], msg?: string): void;
|
|
sameDeepMembers(set1: any[], set2: any[], msg?: string): void;
|
|
includeMembers(superset: any[], subset: any[], msg?: string): void;
|
|
includeDeepMembers(superset: any[], subset: any[], msg?: string): void;
|
|
|
|
ifError(val: any, msg?: string): void;
|
|
|
|
isExtensible(obj: {}, msg?: string): void;
|
|
extensible(obj: {}, msg?: string): void;
|
|
isNotExtensible(obj: {}, msg?: string): void;
|
|
notExtensible(obj: {}, msg?: string): void;
|
|
|
|
isSealed(obj: {}, msg?: string): void;
|
|
sealed(obj: {}, msg?: string): void;
|
|
isNotSealed(obj: {}, msg?: string): void;
|
|
notSealed(obj: {}, msg?: string): void;
|
|
|
|
isFrozen(obj: Object, msg?: string): void;
|
|
frozen(obj: Object, msg?: string): void;
|
|
isNotFrozen(obj: Object, msg?: string): void;
|
|
notFrozen(obj: Object, msg?: string): void;
|
|
|
|
oneOf(inList: any, list: any[], msg?: string): void;
|
|
|
|
changes(fn: Function, obj: {}, property: string): void;
|
|
doesNotChange(fn: Function, obj: {}, property: string): void;
|
|
increases(fn: Function, obj: {}, property: string): void;
|
|
doesNotIncrease(fn: Function, obj: {}, property: string): void;
|
|
|
|
decreases(fn: Function, obj: {}, property: string): void;
|
|
doesNotDecrease(fn: Function, obj: {}, property: string): void;
|
|
}
|
|
}
|
|
declare module 'chai/lib/Assert' {
|
|
export * from '~chai/lib/Assert';
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Assertion.d.ts
|
|
declare module '~chai/lib/Assertion' {
|
|
export interface AssertionStatic {
|
|
(target?: any, message?: string, stack?: Function): Assertion;
|
|
new (target?: any, message?: string, stack?: Function): Assertion;
|
|
}
|
|
|
|
export interface Assertion extends LanguageChains, NumericComparison, TypeComparison {
|
|
not: Assertion;
|
|
deep: Deep;
|
|
any: KeyFilter;
|
|
all: KeyFilter;
|
|
a: TypeComparison;
|
|
an: TypeComparison;
|
|
include: Include;
|
|
includes: Include;
|
|
contain: Include;
|
|
contains: Include;
|
|
ok: Assertion;
|
|
true: Assertion;
|
|
false: Assertion;
|
|
null: Assertion;
|
|
undefined: Assertion;
|
|
NaN: Assertion;
|
|
exist: Assertion;
|
|
empty: Assertion;
|
|
arguments: Assertion;
|
|
Arguments: Assertion;
|
|
equal: Equal;
|
|
equals: Equal;
|
|
eq: Equal;
|
|
eql: Equal;
|
|
eqls: Equal;
|
|
property: Property;
|
|
ownProperty: OwnProperty;
|
|
haveOwnProperty: OwnProperty;
|
|
ownPropertyDescriptor: OwnPropertyDescriptor;
|
|
haveOwnPropertyDescriptor: OwnPropertyDescriptor;
|
|
length: Length;
|
|
lengthOf: Length;
|
|
match: Match;
|
|
matches: Match;
|
|
string(str: string, message?: string): Assertion;
|
|
keys: Keys;
|
|
key(str: string): Assertion;
|
|
throw: Throw;
|
|
throws: Throw;
|
|
Throw: Throw;
|
|
respondTo: RespondTo;
|
|
respondsTo: RespondTo;
|
|
itself: Assertion;
|
|
satisfy: Satisfy;
|
|
satisfies: Satisfy;
|
|
closeTo: CloseTo;
|
|
approximately: CloseTo;
|
|
members: Members;
|
|
increase: PropertyChange;
|
|
increases: PropertyChange;
|
|
decrease: PropertyChange;
|
|
decreases: PropertyChange;
|
|
change: PropertyChange;
|
|
changes: PropertyChange;
|
|
extensible: Assertion;
|
|
sealed: Assertion;
|
|
frozen: Assertion;
|
|
oneOf(list: any[], message?: string): Assertion;
|
|
}
|
|
|
|
export interface LanguageChains {
|
|
to: Assertion;
|
|
be: Assertion;
|
|
been: Assertion;
|
|
is: Assertion;
|
|
that: Assertion;
|
|
which: Assertion;
|
|
and: Assertion;
|
|
has: Assertion;
|
|
have: Assertion;
|
|
with: Assertion;
|
|
at: Assertion;
|
|
of: Assertion;
|
|
same: Assertion;
|
|
}
|
|
|
|
export interface NumericComparison {
|
|
above: NumberComparer;
|
|
gt: NumberComparer;
|
|
greaterThan: NumberComparer;
|
|
least: NumberComparer;
|
|
gte: NumberComparer;
|
|
below: NumberComparer;
|
|
lt: NumberComparer;
|
|
lessThan: NumberComparer;
|
|
most: NumberComparer;
|
|
lte: NumberComparer;
|
|
within(start: number, finish: number, message?: string): Assertion;
|
|
}
|
|
|
|
export interface NumberComparer {
|
|
(value: number, message?: string): Assertion;
|
|
}
|
|
|
|
export interface TypeComparison {
|
|
(type: string, message?: string): Assertion;
|
|
instanceof: InstanceOf;
|
|
instanceOf: InstanceOf;
|
|
}
|
|
|
|
export interface InstanceOf {
|
|
(constructor: Object, message?: string): Assertion;
|
|
}
|
|
|
|
export interface CloseTo {
|
|
(expected: number, delta: number, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Deep {
|
|
equal: Equal;
|
|
equals: Equal;
|
|
eq: Equal;
|
|
include: Include;
|
|
property: Property;
|
|
members: Members;
|
|
}
|
|
|
|
export interface KeyFilter {
|
|
keys: Keys;
|
|
}
|
|
|
|
export interface Equal {
|
|
(value: any, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Property {
|
|
(name: string, value?: any, message?: string): Assertion;
|
|
}
|
|
|
|
export interface OwnProperty {
|
|
(name: string, message?: string): Assertion;
|
|
}
|
|
|
|
export interface OwnPropertyDescriptor {
|
|
(name: string, descriptor: PropertyDescriptor, message?: string): Assertion;
|
|
(name: string, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Length extends LanguageChains, NumericComparison {
|
|
(length: number, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Include {
|
|
(value: Object, message?: string): Assertion;
|
|
(value: string, message?: string): Assertion;
|
|
(value: number, message?: string): Assertion;
|
|
string(value: string, message?: string): Assertion;
|
|
keys: Keys;
|
|
members: Members;
|
|
any: KeyFilter;
|
|
all: KeyFilter;
|
|
}
|
|
|
|
export interface Match {
|
|
(regexp: RegExp | string, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Keys {
|
|
(...keys: any[]): Assertion;
|
|
(keys: any[]): Assertion;
|
|
(keys: Object): Assertion;
|
|
}
|
|
|
|
export interface Throw {
|
|
(): Assertion;
|
|
(expected: string, message?: string): Assertion;
|
|
(expected: RegExp, message?: string): Assertion;
|
|
(constructor: Error, expected?: string, message?: string): Assertion;
|
|
(constructor: Error, expected?: RegExp, message?: string): Assertion;
|
|
(constructor: Function, expected?: string, message?: string): Assertion;
|
|
(constructor: Function, expected?: RegExp, message?: string): Assertion;
|
|
}
|
|
|
|
export interface RespondTo {
|
|
(method: string, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Satisfy {
|
|
(matcher: Function, message?: string): Assertion;
|
|
}
|
|
|
|
export interface Members {
|
|
(set: any[], message?: string): Assertion;
|
|
}
|
|
|
|
export interface PropertyChange {
|
|
(object: Object, prop: string, msg?: string): Assertion;
|
|
}
|
|
}
|
|
declare module 'chai/lib/Assertion' {
|
|
export * from '~chai/lib/Assertion';
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Expect.d.ts
|
|
declare module '~chai/lib/Expect' {
|
|
import {AssertionStatic} from '~chai/lib/Assertion';
|
|
|
|
export interface ExpectStatic extends AssertionStatic {
|
|
fail(actual?: any, expected?: any, message?: string, operator?: string): void;
|
|
}
|
|
}
|
|
declare module 'chai/lib/Expect' {
|
|
export * from '~chai/lib/Expect';
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Should.d.ts
|
|
declare module '~chai/lib/Should' {
|
|
export interface Should extends ShouldAssertion {
|
|
not: ShouldAssertion;
|
|
fail(actual: any, expected: any, message?: string, operator?: string): void;
|
|
}
|
|
|
|
export interface ShouldAssertion {
|
|
Throw: ShouldThrow;
|
|
throw: ShouldThrow;
|
|
equal(value1: any, value2: any, message?: string): void;
|
|
exist(value: any, message?: string): void;
|
|
}
|
|
|
|
export interface ShouldThrow {
|
|
(actual: Function): void;
|
|
(actual: Function, expected: string | RegExp, message?: string): void;
|
|
(actual: Function, constructor: Error | Function, expected?: string | RegExp, message?: string): void;
|
|
}
|
|
}
|
|
declare module 'chai/lib/Should' {
|
|
export * from '~chai/lib/Should';
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Config.d.ts
|
|
declare module '~chai/lib/Config' {
|
|
export interface Config {
|
|
includeStack: boolean;
|
|
showDiff: boolean;
|
|
truncateThreshold: number;
|
|
}
|
|
}
|
|
declare module 'chai/lib/Config' {
|
|
export * from '~chai/lib/Config';
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Utils.d.ts
|
|
declare module '~chai/lib/Utils' {
|
|
import {Assertion} from '~chai/lib/Assertion';
|
|
|
|
export interface PathInfo {
|
|
parent: any;
|
|
name: number|string;
|
|
value: any;
|
|
exists: boolean;
|
|
}
|
|
|
|
export interface Utils {
|
|
addChainableMethod(ctx: any, name: string, chainingBehavior: (value: any) => void): void;
|
|
addMethod(ctx: any, name: string, method: (value: any) => void): void;
|
|
addProperty(ctx: any, name: string, getter: () => void): void;
|
|
expectTypes(obj: Object, types: string[]): void;
|
|
flag(obj: Object, key: string, value?: any): any;
|
|
getActual(obj: Object, actual?: any): any;
|
|
getEnumerableProperties(obj: Object): string[];
|
|
getMessage(obj: Object, params: any[]): string;
|
|
getMessage(obj: Object, message: string, negateMessage: string): string;
|
|
getName(func: Function): string;
|
|
getPathInfo(path: string, obj: Object): PathInfo;
|
|
getPathValue(path: string, obj: Object): any;
|
|
getProperties(obj: Object): string[];
|
|
hasProperty(obj: Object, name: string): boolean;
|
|
transferFlags(assertion: Assertion | any, obj: Object, includeAll?: boolean): void;
|
|
inspect(obj: any): any;
|
|
}
|
|
}
|
|
declare module 'chai/lib/Utils' {
|
|
export * from '~chai/lib/Utils';
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/lib/Chai.d.ts
|
|
declare module '~chai/lib/Chai' {
|
|
import * as AE from '~chai~assertion-error';
|
|
|
|
import * as Assert from '~chai/lib/Assert';
|
|
import * as A from '~chai/lib/Assertion';
|
|
import * as Expect from '~chai/lib/Expect';
|
|
import * as Should from '~chai/lib/Should';
|
|
import * as Config from '~chai/lib/Config';
|
|
import * as Utils from '~chai/lib/Utils';
|
|
|
|
namespace chai {
|
|
export interface AssertionStatic extends A.AssertionStatic {}
|
|
export class AssertionError extends AE.AssertionError {}
|
|
export var Assertion: A.AssertionStatic;
|
|
export var expect: Expect.ExpectStatic;
|
|
export var assert: Assert.AssertStatic;
|
|
export var config: Config.Config;
|
|
export var util: Utils.Utils;
|
|
export function should(): Should.Should;
|
|
export function Should(): Should.Should;
|
|
/**
|
|
* Provides a way to extend the internals of Chai
|
|
*/
|
|
export function use(fn: (chai: any, utils: Utils.Utils) => void): typeof chai;
|
|
}
|
|
|
|
export = chai;
|
|
|
|
/* tslint:disable:no-internal-module */
|
|
global {
|
|
interface Object {
|
|
should: A.Assertion;
|
|
}
|
|
}
|
|
}
|
|
declare module 'chai/lib/Chai' {
|
|
import main = require('~chai/lib/Chai');
|
|
export = main;
|
|
}
|
|
|
|
// Generated by typings
|
|
// Source: https://raw.githubusercontent.com/types/npm-chai/793bee097a6a644e078a033603d88ac89eb7b560/index.d.ts
|
|
declare module 'chai' {
|
|
// Type definitions for chai 3.4.0
|
|
// Project: http://chaijs.com/
|
|
// Original Definitions by: Jed Mao <https://github.com/jedmao/>,
|
|
// Bart van der Schoor <https://github.com/Bartvds>,
|
|
// Andrew Brown <https://github.com/AGBrown>,
|
|
// Olivier Chevet <https://github.com/olivr70>,
|
|
// Matt Wistrand <https://github.com/mwistrand>
|
|
|
|
import chai = require('~chai/lib/Chai');
|
|
|
|
export = chai;
|
|
}
|