diff --git a/chai-as-promised/chai-as-promised-tests.ts b/chai-as-promised/chai-as-promised-tests.ts
new file mode 100644
index 000000000..20a773cdd
--- /dev/null
+++ b/chai-as-promised/chai-as-promised-tests.ts
@@ -0,0 +1,22 @@
+/// <reference path="../chai/chai.d.ts" />
+/// <reference path="chai-as-promised.d.ts" />
+
+import chai = require('chai');
+import chaiAsPromised = require('chai-as-promised');
+
+chai.use(chaiAsPromised);
+
+var promise: any;
+chai.expect(promise).to.eventually.equal(3);
+chai.expect(promise).to.become(3);
+chai.expect(promise).to.be.rejected;
+chai.expect(promise).to.be.rejectedWith(Error);
+chai.expect(promise).to.notify(() => console.log('done'));
+
+chai.assert.eventually.equal(promise, 4, 'Message');
+chai.assert.isFulfilled(promise, "optional message");
+chai.assert.becomes(promise, "foo", "optional message");
+chai.assert.doesNotBecome(promise, "foo", "optional message");
+chai.assert.isRejected(promise, "optional message");
+chai.assert.isRejected(promise, Error, "optional message");
+chai.assert.isRejected(promise, /error message matcher/, "optional message");
diff --git a/chai-as-promised/chai-as-promised.d.ts b/chai-as-promised/chai-as-promised.d.ts
new file mode 100644
index 000000000..20b697bb5
--- /dev/null
+++ b/chai-as-promised/chai-as-promised.d.ts
@@ -0,0 +1,35 @@
+// Type definitions for chai-as-promised
+// Project: https://github.com/domenic/chai-as-promised/
+// Definitions by: jt000 <https://github.com/jt000>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../chai/chai.d.ts" />
+
+declare module 'chai-as-promised' {
+    import chai = require('chai');
+
+    function chaiAsPromised(chai: any, utils: any): void;
+
+    export = chaiAsPromised;
+}
+
+declare module chai {
+
+    interface LanguageChains {
+        become(expected: any): Expect;
+        eventually: Expect;
+        rejected: Expect;
+        rejectedWith(expected: any): Expect;
+        notify(fn: Function): Expect;
+    }
+
+    interface Assert {
+        eventually: Assert;
+        isFulfilled(promise: any, message?: string): void;
+        becomes(promise: any, expected: any, message?: string): void;
+        doesNotBecome(promise: any, expected: any, message?: string): void;
+        isRejected(promise: any, message?: string): void;
+        isRejected(promise: any, expected: any, message?: string): void;
+        isRejected(promise: any, match: RegExp, message?: string): void;
+    }
+}
\ No newline at end of file
diff --git a/mocha/mocha-tests.ts b/mocha/mocha-tests.ts
index 672fac1cb..dffd86e44 100644
--- a/mocha/mocha-tests.ts
+++ b/mocha/mocha-tests.ts
@@ -167,3 +167,58 @@ function test_chaining(){
         .reporter('html')
         .reporter(function(){});
 }
+
+import MochaDef = require('mocha');
+
+function test_require_constructor_empty() {
+    var instance = new MochaDef();
+}
+
+function test_require_constructor_noOptions() {
+    var instance = new MochaDef({});
+}
+
+function test_require_constructor_allOptions() {
+    var instance = new MochaDef({
+        grep: /[a-z]*/,
+        ui: 'tdd',
+        reporter: 'dot',
+        timeout: 500,
+        bail: true
+    });
+}
+
+
+function test_require_fluentParams() {
+    var instance = new MochaDef();
+
+    instance.bail(true)
+        .bail()
+        .addFile('foo.js')
+        .reporter('bdd')
+        .ui('dot')
+        .grep('[a-z]*')
+        .grep(/[a-z]*/)
+        .invert()
+        .ignoreLeaks(true)
+        .checkLeaks()
+        .growl()
+        .globals('foo')
+        .globals(['bar', 'zap'])
+        .useColors(true)
+        .useInlineDiffs(true)
+        .timeout(500)
+        .slow(100)
+        .enableTimeouts(true)
+        .asyncOnly(false)
+        .noHighlighting(true)
+        .run();
+}
+
+function test_run_withOnComplete() {
+    var instance = new MochaDef();
+
+    instance.run((failures: number): void => {
+        console.log(failures);
+    });
+}
\ No newline at end of file
diff --git a/mocha/mocha.d.ts b/mocha/mocha.d.ts
index 64255a7ba..6a2a53959 100644
--- a/mocha/mocha.d.ts
+++ b/mocha/mocha.d.ts
@@ -1,6 +1,6 @@
-// Type definitions for mocha 1.17.1
-// Project: http://visionmedia.github.io/mocha/
-// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid/>, otiai10 <https://github.com/otiai10>
+// Type definitions for mocha 2.0.1
+// Project: http://mochajs.org/
+// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid/>, otiai10 <https://github.com/otiai10>, jt000 <https://github.com/jt000>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 interface Mocha {
@@ -108,3 +108,40 @@ declare function afterEach(action: (done: MochaDone) => void): void;
 declare function suiteTeardown(action: () => void): void;
 
 declare function suiteTeardown(action: (done: MochaDone) => void): void;
+
+declare module "mocha" {
+
+    class Mocha {
+        constructor(options?: {
+            grep?: RegExp;
+            ui?: string;
+            reporter?: string;
+            timeout?: number;
+            bail?: boolean;
+        });
+
+        bail(value?: boolean): Mocha;
+        addFile(file: string): Mocha;
+        reporter(value: string): Mocha;
+        ui(value: string): Mocha;
+        grep(value: string): Mocha;
+        grep(value: RegExp): Mocha;
+        invert(): Mocha;
+        ignoreLeaks(value: boolean): Mocha;
+        checkLeaks(): Mocha;
+        growl(): Mocha;
+        globals(value: string): Mocha;
+        globals(values: string[]): Mocha;
+        useColors(value: boolean): Mocha;
+        useInlineDiffs(value: boolean): Mocha;
+        timeout(value: number): Mocha;
+        slow(value: number): Mocha;
+        enableTimeouts(value: boolean): Mocha;
+        asyncOnly(value: boolean): Mocha;
+        noHighlighting(value: boolean): Mocha;
+
+        run(onComplete?: (failures: number) => void): void;
+    }
+
+    export = Mocha;
+}
diff --git a/mockery/mockery-test.ts b/mockery/mockery-test.ts
new file mode 100644
index 000000000..d8623b3aa
--- /dev/null
+++ b/mockery/mockery-test.ts
@@ -0,0 +1,41 @@
+/// <reference path="mockery.d.ts" />
+
+import mockery = require('mockery');
+
+mockery.enable();
+mockery.enable({});
+mockery.enable({
+    useCleanCache: true,
+    warnOnReplace: true,
+    warnOnUnregistered: true
+});
+
+mockery.disable();
+
+var fsMock = {
+    stat: (path: any, cb: any) => { /* your mock code */ }
+};
+mockery.registerMock('fs', fsMock);
+
+mockery.deregisterMock('fs');
+
+mockery.registerSubstitute('fs', 'fs-mock');
+
+mockery.deregisterSubstitute('fs');
+
+mockery.registerAllowable('./my-source-under-test');
+mockery.registerAllowable('./my-source-under-test', true);
+
+mockery.deregisterAllowable('./my-source-under-test');
+
+mockery.registerAllowables(['async', 'path', 'util']);
+
+mockery.deregisterAllowables(['async', 'path', 'util']);
+
+mockery.deregisterAll();
+
+mockery.resetCache();
+
+mockery.warnOnUnregistered(false);
+
+mockery.warnOnReplace(false);
\ No newline at end of file
diff --git a/mockery/mockery.d.ts b/mockery/mockery.d.ts
new file mode 100644
index 000000000..f4d98de2b
--- /dev/null
+++ b/mockery/mockery.d.ts
@@ -0,0 +1,33 @@
+// Type definitions for mockery 1.4.0
+// Project: https://github.com/mfncooper/mockery
+// Definitions by: jt000 <https://github.com/jt000>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "mockery" {
+
+    interface MockeryEnableArgs {
+        useCleanCache?: boolean;
+        warnOnReplace?: boolean;
+        warnOnUnregistered?: boolean;
+    }
+
+    export function enable(args?: MockeryEnableArgs): void;
+    export function disable(): void;
+
+    export function registerMock(name: string, mock: any): void;
+    export function deregisterMock(name: string): void;
+
+    export function registerSubstitute(name: string, substitute: string): void;
+    export function deregisterSubstitute(name: string): void;
+
+    export function registerAllowable(name: string, unhook?: boolean): void;
+    export function deregisterAllowable(name: string): void;
+
+    export function registerAllowables(names: string[]): void;
+    export function deregisterAllowables(names: string[]): void;
+
+    export function deregisterAll(): void;
+    export function resetCache(): void;
+    export function warnOnUnregistered(value: boolean): void;
+    export function warnOnReplace(value: boolean): void;
+}
\ No newline at end of file
diff --git a/mongoose-mock/mongoose-mock-tests.ts b/mongoose-mock/mongoose-mock-tests.ts
new file mode 100644
index 000000000..4f364cf97
--- /dev/null
+++ b/mongoose-mock/mongoose-mock-tests.ts
@@ -0,0 +1,7 @@
+/// <reference path="../mongoose/mongoose.d.ts" />
+/// <reference path="mongoose-mock.d.ts" />
+
+import mongooseMock = require('mongoose-mock');
+
+// returns a mongoose object
+mongooseMock.connect('url');
\ No newline at end of file
diff --git a/mongoose-mock/mongoose-mock.d.ts b/mongoose-mock/mongoose-mock.d.ts
new file mode 100644
index 000000000..90d6327b4
--- /dev/null
+++ b/mongoose-mock/mongoose-mock.d.ts
@@ -0,0 +1,13 @@
+// Type definitions for mongoose-mock 0.4.0
+// Project: https://github.com/JohanObrink/mongoose-mock
+// Definitions by: jt000 <https://github.com/jt000>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../mongoose/mongoose.d.ts" />
+
+declare module "mongoose-mock" {
+    import mongoose = require('mongoose');
+
+    var mock: mongoose.Mongoose;
+    export = mock;
+}
\ No newline at end of file
diff --git a/multer/multer-tests.ts b/multer/multer-tests.ts
new file mode 100644
index 000000000..8131293f5
--- /dev/null
+++ b/multer/multer-tests.ts
@@ -0,0 +1,8 @@
+/// <reference path="../express/express.d.ts" />
+/// <reference path="multer.d.ts" />
+
+import express = require('express');
+import multer = require('multer');
+
+var app: express.Express = express();
+app.use(multer());
\ No newline at end of file
diff --git a/multer/multer.d.ts b/multer/multer.d.ts
new file mode 100644
index 000000000..b188c22ae
--- /dev/null
+++ b/multer/multer.d.ts
@@ -0,0 +1,14 @@
+// Type definitions for multer
+// Project: https://github.com/expressjs/multer
+// Definitions by: jt000 <https://github.com/jt000>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../express/express.d.ts" />
+
+declare module "multer" {
+    import express = require('express');
+
+    function multer(options?: any): express.RequestHandler;
+
+    export = multer;
+}
\ No newline at end of file
diff --git a/proxyquire/proxyquire-test.ts b/proxyquire/proxyquire-test.ts
new file mode 100644
index 000000000..b1985de58
--- /dev/null
+++ b/proxyquire/proxyquire-test.ts
@@ -0,0 +1,19 @@
+/// <reference path="./proxyquire.d.ts" />
+
+import proxyquire = require('proxyquire');
+
+class Foo {}
+var mock = {};
+
+var myModule = proxyquire('myModule', mock);
+var fooModule: Foo = proxyquire<Foo>('foo', mock);
+
+myModule = proxyquire.noCallThru()
+                     .load('myModule', mock);
+
+fooModule = proxyquire.callThru()
+                      .load<Foo>('foo', mock);
+
+proxyquire.preserveCache();
+
+proxyquire.noPreserveCache();
diff --git a/proxyquire/proxyquire.d.ts b/proxyquire/proxyquire.d.ts
new file mode 100644
index 000000000..06e1c773e
--- /dev/null
+++ b/proxyquire/proxyquire.d.ts
@@ -0,0 +1,25 @@
+// Type definitions for Proxyquire 1.3.0
+// Project: https://github.com/thlorenz/proxyquire
+// Definitions by: jt000 <https://github.com/jt000/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Proxyquire {
+
+    (request: string, stubs: any): any;
+    <T>(request: string, stubs: any): T;
+
+    load(request: string, stubs: any): any;
+    load<T>(request: string, stubs: any): T;
+
+    noCallThru(): Proxyquire;
+    callThru(): Proxyquire;
+
+    noPreserveCache(): void;
+    preserveCache(): void;
+}
+
+declare module 'proxyquire' {
+
+    var p: Proxyquire;
+    export = p;
+}
\ No newline at end of file