diff --git a/typescript-deferred/typescript-deferred-tests.ts b/typescript-deferred/typescript-deferred-tests.ts
new file mode 100644
index 000000000..0bfa82582
--- /dev/null
+++ b/typescript-deferred/typescript-deferred-tests.ts
@@ -0,0 +1,61 @@
+/// <reference path="./typescript-deferred.d.ts"/>
+
+import tsd = require('typescript-deferred');
+
+var t1: tsd.PromiseInterface<string> = tsd.when(10)
+    .then(() => tsd.when('foo'));
+
+var t2: tsd. PromiseInterface<string> = tsd.when(10)
+    .then(() => 'foo');
+
+var t3: tsd.PromiseInterface<string> = tsd.when(10)
+    .then(() => 'foo', () => tsd.when('bar'));
+
+var t4: tsd.PromiseInterface<string> = tsd.when(10)
+    .then(() => 'foo', () => 'bar');
+
+var t5: tsd.PromiseInterface<string> = tsd.when(10)
+    .then(() => tsd.when('foo'), () => 'bar');
+
+var t6: tsd.PromiseInterface<string> = tsd.when(10)
+    .then(() => tsd.when('foo'), () => tsd.when('bar'));
+
+var t7: tsd.PromiseInterface<string> = tsd.when(10)
+    .always(() => 'foo');
+
+var t8: tsd.PromiseInterface<string> = tsd.when(10)
+    .always(() => tsd.when('foo'));
+
+var t9: tsd.PromiseInterface<number> = tsd.when(10)
+    .otherwise(() => 11);
+
+var t10: tsd.PromiseInterface<number> = tsd.when(10)
+    .otherwise(() => tsd.when(11));
+
+var t11: tsd.PromiseInterface<string> = tsd.when('foo');
+
+var t12: tsd.PromiseInterface<string> = tsd.when(tsd.when('foo'));
+
+var t13: tsd.PromiseInterface<string> = tsd.create<string>()
+    .promise;
+
+var t14: tsd.DeferredInterface<string> = tsd.create<string>();
+
+var t15: tsd.ThenableInterface<string> = tsd.when('foo');
+
+var t16: tsd.PromiseInterface<string> = tsd.when(<tsd.ThenableInterface<string> >tsd.when('foo'));
+
+var t17: tsd.PromiseInterface<string> = tsd.when(10)
+    .then(() => <tsd.ThenableInterface<string> >tsd.when('foo'), () => <tsd.ThenableInterface<string> >tsd.when('bar'));
+
+var t18: tsd.PromiseInterface<string> = tsd.create<string>()
+    .resolve('foo')
+    .promise;
+
+var t19: tsd.PromiseInterface<string> = tsd.create<string>()
+    .resolve(tsd.when('foo'))
+    .promise;
+
+var t20: tsd.PromiseInterface<string> = tsd.create<string>()
+    .reject(new Error('foo'))
+    .promise;
diff --git a/typescript-deferred/typescript-deferred.d.ts b/typescript-deferred/typescript-deferred.d.ts
new file mode 100644
index 000000000..bffc65b70
--- /dev/null
+++ b/typescript-deferred/typescript-deferred.d.ts
@@ -0,0 +1,47 @@
+// Type definitions for typescript-deferred v0.1.5
+// Project: https://github.com/DirtyHairy/typescript-deferred
+// Definitions by: Christian Speckner <https://github.com/DirtyHairy>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "typescript-deferred" {
+
+    export interface ImmediateSuccessCB<T, TP> {
+        (value: T): TP;
+    }
+    export interface ImmediateErrorCB<TP> {
+        (err: any): TP;
+    }
+    export interface DeferredSuccessCB<T, TP> {
+        (value: T): ThenableInterface<TP>;
+    }
+    export interface DeferredErrorCB<TP> {
+        (error: any): ThenableInterface<TP>;
+    }
+    export interface ThenableInterface<T> {
+        then<TP>(successCB?: DeferredSuccessCB<T, TP>, errorCB?: DeferredErrorCB<TP>): ThenableInterface<TP>;
+        then<TP>(successCB?: DeferredSuccessCB<T, TP>, errorCB?: ImmediateErrorCB<TP>): ThenableInterface<TP>;
+        then<TP>(successCB?: ImmediateSuccessCB<T, TP>, errorCB?: DeferredErrorCB<TP>): ThenableInterface<TP>;
+        then<TP>(successCB?: ImmediateSuccessCB<T, TP>, errorCB?: ImmediateErrorCB<TP>): ThenableInterface<TP>;
+    }
+    export interface PromiseInterface<T> extends ThenableInterface<T> {
+        then<TP>(successCB?: DeferredSuccessCB<T, TP>, errorCB?: DeferredErrorCB<TP>): PromiseInterface<TP>;
+        then<TP>(successCB?: DeferredSuccessCB<T, TP>, errorCB?: ImmediateErrorCB<TP>): PromiseInterface<TP>;
+        then<TP>(successCB?: ImmediateSuccessCB<T, TP>, errorCB?: DeferredErrorCB<TP>): PromiseInterface<TP>;
+        then<TP>(successCB?: ImmediateSuccessCB<T, TP>, errorCB?: ImmediateErrorCB<TP>): PromiseInterface<TP>;
+        otherwise(errorCB?: DeferredErrorCB<T>): PromiseInterface<T>;
+        otherwise(errorCB?: ImmediateErrorCB<T>): PromiseInterface<T>;
+        always<TP>(errorCB?: DeferredErrorCB<TP>): PromiseInterface<TP>;
+        always<TP>(errorCB?: ImmediateErrorCB<TP>): PromiseInterface<TP>;
+    }
+    export interface DeferredInterface<T> {
+        resolve(value?: ThenableInterface<T>): DeferredInterface<T>;
+        resolve(value?: T): DeferredInterface<T>;
+        reject(error?: any): DeferredInterface<T>;
+        promise: PromiseInterface<T>;
+    }
+    export function create<T>(): DeferredInterface<T>;
+    export function when<T>(value?: ThenableInterface<T>): PromiseInterface<T>;
+    export function when<T>(value?: T): PromiseInterface<T>;
+    
+
+}