Add config file specifically in prettier command and fix files

3 files changed, 253 insertions, 253 deletions

diff --git a/packages/chai-as-promised-typescript-typings/index.d.ts b/packages/chai-as-promised-typescript-typings/index.d.ts
index 389a076c6..ba6dabdcc 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 77985de05..bea3d273d 100644
--- a/packages/chai-as-promised-typescript-typings/package.json
+++ b/packages/chai-as-promised-typescript-typings/package.json
@@ -1,21 +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 ef528b22e..9a93a1f74 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"]
 }