Fix prettier

3 files changed, 253 insertions, 255 deletions

diff --git a/packages/chai-as-promised-typescript-typings/index.d.ts b/packages/chai-as-promised-typescript-typings/index.d.ts
index ba6dabdcc..389a076c6 100644
--- a/packages/chai-as-promised-typescript-typings/index.d.ts
+++ b/packages/chai-as-promised-typescript-typings/index.d.ts
@@ -4,265 +4,265 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare module 'chai-as-promised' {
-    function chaiAsPromised(chai: any, utils: any): void;
-    namespace chaiAsPromised {
+	function chaiAsPromised(chai: any, utils: any): void;
+	namespace chaiAsPromised {
 
-    }
-    export = 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>;
+	// 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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		include(exp: string | any[], inc: any, msg?: string): PromiseLike<void>;
 
-        notInclude(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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
+		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>;
-    }
+		ifError(val: any, msg?: string): PromiseLike<void>;
+	}
 }
diff --git a/packages/chai-as-promised-typescript-typings/package.json b/packages/chai-as-promised-typescript-typings/package.json
index bde308547..77985de05 100644
--- a/packages/chai-as-promised-typescript-typings/package.json
+++ b/packages/chai-as-promised-typescript-typings/package.json
@@ -1,23 +1,21 @@
 {
-    "name": "chai-as-promised-typescript-typings",
-    "version": "0.0.6",
-    "description": "Typescript type definitions for chai-as-promised",
-    "main": "index.d.ts",
-    "types": "index.d.ts",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/0xProject/0x.js.git"
-    },
-    "author": "Fabio Berger",
-    "contributors": [
-        "Leonid Logvinov <logvinov.leon@gmail.com>"
-    ],
-    "license": "Apache-2.0",
-    "bugs": {
-        "url": "https://github.com/0xProject/0x.js/issues"
-    },
-    "homepage": "https://github.com/0xProject/0x.js/packages/chai-as-promised-typescript-typings#readme",
-    "dependencies": {
-        "chai-typescript-typings": "^0.0.0"
-    }
+	"name": "chai-as-promised-typescript-typings",
+	"version": "0.0.6",
+	"description": "Typescript type definitions for chai-as-promised",
+	"main": "index.d.ts",
+	"types": "index.d.ts",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/0xProject/0x.js.git"
+	},
+	"author": "Fabio Berger",
+	"contributors": ["Leonid Logvinov <logvinov.leon@gmail.com>"],
+	"license": "Apache-2.0",
+	"bugs": {
+		"url": "https://github.com/0xProject/0x.js/issues"
+	},
+	"homepage": "https://github.com/0xProject/0x.js/packages/chai-as-promised-typescript-typings#readme",
+	"dependencies": {
+		"chai-typescript-typings": "^0.0.0"
+	}
 }
diff --git a/packages/chai-as-promised-typescript-typings/tslint.json b/packages/chai-as-promised-typescript-typings/tslint.json
index 9a93a1f74..ef528b22e 100644
--- a/packages/chai-as-promised-typescript-typings/tslint.json
+++ b/packages/chai-as-promised-typescript-typings/tslint.json
@@ -1,3 +1,3 @@
 {
-    "extends": ["tslint-config-0xproject"]
+	"extends": ["tslint-config-0xproject"]
 }