diff --git a/when/when.d.ts b/when/when.d.ts
index 5db15b316..be5e25f15 100644
--- a/when/when.d.ts
+++ b/when/when.d.ts
@@ -12,29 +12,79 @@ declare function When<T, U>(value: When.Thenable<T>, transform: (val: T) => U):
 declare function When<T, U>(value: T, transform: (val: T) => U): When.Promise<U>;
 
 declare module When {
-    function attempt<T>(f: () => T): Promise<T>;
+    // Helper interfaces
+    module _ {
+        interface Fn0<T> { (): T }
+        interface Fn1<A1, T> { (a1: A1): T }
+        interface Fn2<A1, A2, T> { (a1: A1, a2: A2): T }
+        interface Fn3<A1, A2, A3, T> { (a1: A1, a2: A2, a3: A3): T }
+        interface Fn4<A1, A2, A3, A4, T> { (a1: A1, a2: A2, a3: A3, a4: A4): T }
+        interface Fn5<A1, A2, A3, A4, A5, T> { (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5): T }
+        interface Fn6<A1, A2, A3, A4, A5, A6, T> { (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6): T }
 
-    function attempt<T, A>(f: (a: A) => T, a: Promise<A>): Promise<T>;
-    function attempt<T, A>(f: (a: A) => T, a: A): Promise<T>;
+        interface LiftedFn0<T> extends Fn0<Promise<T>> { }
+        interface LiftedFn1<A1, T> extends Fn1<A1 | Promise<A1>, Promise<T>> { }
+        interface LiftedFn2<A1, A2, T> extends Fn2<A1 | Promise<A1>, A2 | Promise<A2>, Promise<T>> { }
+        interface LiftedFn3<A1, A2, A3, T> extends Fn3<A1 | Promise<A1>, A2 | Promise<A2>, A3 | Promise<A3>, Promise<T>> { }
+        interface LiftedFn4<A1, A2, A3, A4, T> extends Fn4<A1 | Promise<A1>, A2 | Promise<A2>, A3 | Promise<A3>, A4 | Promise<A4>, Promise<T>> { }
+        interface LiftedFn5<A1, A2, A3, A4, A5, T> extends Fn5<A1 | Promise<A1>, A2 | Promise<A2>, A3 | Promise<A3>, A4 | Promise<A4>, A5 | Promise<A5>, Promise<T>> { }
 
-    function attempt<T, A, B>(f: (a: A, b: B) => T, a: Promise<A>, b: Promise<B>): Promise<T>;
-    function attempt<T, A, B>(f: (a: A, b: B) => T, a: Promise<A>, b: B): Promise<T>;
-    function attempt<T, A, B>(f: (a: A, b: B) => T, a: A, b: Promise<B>): Promise<T>;
-    function attempt<T, A, B>(f: (a: A, b: B) => T, a: A, b: B): Promise<T>;
+        interface NodeCallback<T> { (err: any, result: T): void }
 
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: Promise<B>, c: Promise<C>): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: Promise<B>, c: C): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: B, c: Promise<C>): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: Promise<A>, b: B, c: C): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: Promise<B>, c: Promise<C>): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: Promise<B>, c: C): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: B, c: Promise<C>): Promise<T>;
-    function attempt<T, A, B, C>(f: (a: A, b: B, c: C) => T, a: A, b: B, c: C): Promise<T>;
+        interface NodeFn0<T> extends _.Fn1<NodeCallback<T>, void> { }
+        interface NodeFn1<A1, T> extends _.Fn2<A1, NodeCallback<T>, void> { }
+        interface NodeFn2<A1, A2, T> extends _.Fn3<A1, A2, NodeCallback<T>, void> { }
+        interface NodeFn3<A1, A2, A3, T> extends _.Fn4<A1, A2, A3, NodeCallback<T>, void> { }
+        interface NodeFn4<A1, A2, A3, A4, T> extends _.Fn5<A1, A2, A3, A4, NodeCallback<T>, void> { }
+        interface NodeFn5<A1, A2, A3, A4, A5, T> extends _.Fn6<A1, A2, A3, A4, A5, NodeCallback<T>, void> { }
+    }
 
-    function lift<T>(f: () => T): () => Promise<T>;
-    function lift<T, A>(f: (a: A) => T): (a: Promise<A>) => Promise<T>;
-    function lift<T, A, B>(f: (a: A, b: B) => T): (a: Promise<A>, b: Promise<B>) => Promise<T>;
-    function lift<T, A, B, C>(f: (a: A, b: B, c: C) => T): (a: Promise<A>, b: Promise<B>, c: Promise<C>) => Promise<T>;
+    function attempt<T>(
+        f: _.Fn0<T>
+    ): Promise<T>;
+
+    function attempt<A1, T>(
+        f: _.Fn1<A1, T>,
+        arg1: A1 | Promise<A1>
+    ): Promise<T>;
+
+    function attempt<A1, A2, T>(
+        f: _.Fn2<A1, A2, T>,
+        arg1: A1 | Promise<A1>,
+        arg2: A2 | Promise<A2>
+    ): Promise<T>;
+
+    function attempt<A1, A2, A3, T>(
+        f: _.Fn3<A1, A2, A3, T>,
+        arg1: A1 | Promise<A1>,
+        arg2: A2 | Promise<A2>,
+        arg3: A3 | Promise<A3>
+    ): Promise<T>;
+
+    function attempt<A1, A2, A3, A4, T>(
+        f: _.Fn4<A1, A2, A3, A4, T>,
+        arg1: A1 | Promise<A1>,
+        arg2: A2 | Promise<A2>,
+        arg3: A3 | Promise<A3>,
+        arg4: A4 | Promise<A4>
+    ): Promise<T>;
+
+    function attempt<A1, A2, A3, A4, A5, T>(
+        f: _.Fn5<A1, A2, A3, A4, A5, T>,
+        arg1: A1 | Promise<A1>,
+        arg2: A2 | Promise<A2>,
+        arg3: A3 | Promise<A3>,
+        arg4: A4 | Promise<A4>,
+        arg5: A5 | Promise<A5>
+    ): Promise<T>;
+
+
+    function lift<T>(f: _.Fn0<T>): _.LiftedFn0<T>;
+    function lift<A1, T>(f: _.Fn1<A1, T>): _.LiftedFn1<A1, T>;
+    function lift<A1, A2, T>(f: _.Fn2<A1, A2, T>): _.LiftedFn2<A1, A2, T>;
+    function lift<A1, A2, A3, T>(f: _.Fn3<A1, A2, A3, T>): _.LiftedFn3<A1, A2, A3, T>;
+    function lift<A1, A2, A3, A4, T>(f: _.Fn4<A1, A2, A3, A4, T>): _.LiftedFn4<A1, A2, A3, A4, T>;
+    function lift<A1, A2, A3, A4, A5, T>(f: _.Fn5<A1, A2, A3, A4, A5, T>): _.LiftedFn5<A1, A2, A3, A4, A5, T>;
 
     function promise<T>(resolver: (resolve: (value: T) => void, reject: (reason: any) => void) => void): Promise<T>;
 
@@ -92,16 +142,13 @@ declare module When {
     }
 
     interface Promise<T> {
-        catch<U>(onRejected?: (reason: any) => Promise<U>): Promise<U>;
-        catch<U>(onRejected?: (reason: any) => U): Promise<U>;
+        catch<U>(onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
 
-        catch<U>(filter: (reason: any) => boolean, onRejected?: (reason: any) => Promise<U>): Promise<U>;
-        catch<U>(filter: (reason: any) => boolean, onRejected?: (reason: any) => U): Promise<U>;
+        catch<U>(filter: (reason: any) => boolean, onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
 
         // Make sure you test any usage of these overloads, exceptionType must
         // be a constructor with prototype set to an instance of Error.
         catch<U>(exceptionType: any, onRejected?: (reason: any) => Promise<U>): Promise<U>;
-        catch<U>(exceptionType: any, onRejected?: (reason: any) => U): Promise<U>;
 
         finally(onFulfilledOrRejected: Function): Promise<T>;
 
@@ -109,8 +156,7 @@ declare module When {
 
         inspect(): Snapshot<T>;
 
-        yield<U>(value: Promise<U>): Promise<U>;
-        yield<U>(value: U): Promise<U>;
+        yield<U>(value: U | Promise<U>): Promise<U>;
 
         else(value: T): Promise<T>;
         orElse(value: T): Promise<T>;
@@ -124,29 +170,19 @@ declare module When {
         with(thisArg: any): Promise<T>;
         withThis(thisArg: any): Promise<T>;
 
-        otherwise<U>(onRejected?: (reason: any) => Promise<U>): Promise<U>;
-        otherwise<U>(onRejected?: (reason: any) => U): Promise<U>;
+        otherwise<U>(onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
 
-        otherwise<U>(predicate: (reason: any) => boolean, onRejected?: (reason: any) => Promise<U>): Promise<U>;
-        otherwise<U>(predicate: (reason: any) => boolean, onRejected?: (reason: any) => U): Promise<U>;
+        otherwise<U>(predicate: (reason: any) => boolean, onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
 
         // Make sure you test any usage of these overloads, exceptionType must
         // be a constructor with prototype set to an instance of Error.
-        otherwise<U>(exceptionType: any, onRejected?: (reason: any) => Promise<U>): Promise<U>;
-        otherwise<U>(exceptionType: any, onRejected?: (reason: any) => U): Promise<U>;
+        otherwise<U>(exceptionType: any, onRejected?: (reason: any) => U | Promise<U>): Promise<U>;
 
-        then<U>(onFulfilled: (value: T) => Promise<U>, onRejected?: (reason: any) => Promise<U>, onProgress?: (update: any) => void): Promise<U>;
-        then<U>(onFulfilled: (value: T) => Promise<U>, onRejected?: (reason: any) => U, onProgress?: (update: any) => void): Promise<U>;
-        then<U>(onFulfilled: (value: T) => U, onRejected?: (reason: any) => Promise<U>, onProgress?: (update: any) => void): Promise<U>;
-        then<U>(onFulfilled: (value: T) => U, onRejected?: (reason: any) => U, onProgress?: (update: any) => void): Promise<U>;
+        then<U>(onFulfilled: (value: T) => U | Promise<U>, onRejected?: (reason: any) => U | Promise<U>, onProgress?: (update: any) => void): Promise<U>;
 
         done<U>(onFulfilled: (value: T) => void, onRejected?: (reason: any) => void): void;
 
-        fold<U, V>(combine: (value1: T, value2: V) => Promise<U>, value2: V): Promise<U>;
-        fold<U, V>(combine: (value1: T, value2: V) => Promise<U>, value2: Promise<V>): Promise<U>;
-
-        fold<U, V>(combine: (value1: T, value2: V) => U, value2: V): Promise<U>;
-        fold<U, V>(combine: (value1: T, value2: V) => U, value2: Promise<V>): Promise<U>;
+        fold<U, V>(combine: (value1: T, value2: V) => U | Promise<U>, value2: V | Promise<V>): Promise<U>;
     }
 
     interface Thenable<T> {
@@ -166,42 +202,67 @@ declare module "when" {
 
 declare module "when/node" {
     import when = require('when');
+    import _ = when._;
 
-    function lift<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => when.Promise<TResult>;
-    function lift<TArg1, TResult>(fn: (arg1: TArg1, callback: (err: any, result: TResult) => void) => void): (arg1: when.Promise<TArg1>) => when.Promise<TResult>;
-    function lift<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void): (arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>) => when.Promise<TResult>;
-    function lift<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void): (arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>, arg3: when.Promise<TArg3>) => when.Promise<TResult>;
+    function lift<T>(fn: _.NodeFn0<T>): _.LiftedFn0<T>;
+    function lift<A1, T>(fn: _.NodeFn1<A1, T>): _.LiftedFn1<A1, T>;
+    function lift<A1, A2, T>(fn: _.NodeFn2<A1, A2, T>): _.LiftedFn2<A1, A2, T>;
+    function lift<A1, A2, A3, T>(fn: _.NodeFn3<A1, A2, A3, T>): _.LiftedFn3<A1, A2, A3, T>;
+    function lift<A1, A2, A3, A4, T>(fn: _.NodeFn4<A1, A2, A3, A4, T>): _.LiftedFn4<A1, A2, A3, A4, T>;
+    function lift<A1, A2, A3, A4, A5, T>(fn: _.NodeFn5<A1, A2, A3, A4, A5, T>): _.LiftedFn5<A1, A2, A3, A4, A5, T>;
+
+
+    function call<T>(
+        fn: _.NodeFn0<T>
+    ): when.Promise<T>;
+
+    function call<A1, T>(
+        fn: _.NodeFn1<A1, T>,
+        arg1: A1 | when.Promise<A1>
+    ): when.Promise<T>;
+
+    function call<A1, A2, T>(
+        fn: _.NodeFn2<A1, A2, T>,
+        arg1: A1 | when.Promise<A1>,
+        arg2: A2 | when.Promise<A2>
+    ): when.Promise<T>;
+
+    function call<A1, A2, A3, T>(
+        fn: _.NodeFn3<A1, A2, A3, T>,
+        arg1: A1 | when.Promise<A1>,
+        arg2: A2 | when.Promise<A2>,
+        arg3: A3 | when.Promise<A3>
+    ): when.Promise<T>;
+
+    function call<A1, A2, A3, A4, T>(
+        fn: _.NodeFn4<A1, A2, A3, A4, T>,
+        arg1: A1 | when.Promise<A1>,
+        arg2: A2 | when.Promise<A2>,
+        arg3: A3 | when.Promise<A3>,
+        arg4: A4 | when.Promise<A4>
+    ): when.Promise<T>;
+
+    function call<A1, A2, A3, A4, A5, T>(
+        fn: _.NodeFn5<A1, A2, A3, A4, A5, T>,
+        arg1: A1 | when.Promise<A1>,
+        arg2: A2 | when.Promise<A2>,
+        arg3: A3 | when.Promise<A3>,
+        arg4: A4 | when.Promise<A4>,
+        arg5: A5 | when.Promise<A5>
+    ): when.Promise<T>;
+
+
+    function apply<T>(fn: _.NodeFn0<T>, args: any[]): when.Promise<T>;
+    function apply<T>(fn: _.NodeFn1<any, T>, args: any[]): when.Promise<T>;
+    function apply<T>(fn: _.NodeFn2<any, any, T>, args: any[]): when.Promise<T>;
+    function apply<T>(fn: _.NodeFn3<any, any, any, T>, args: any[]): when.Promise<T>;
+    function apply<T>(fn: _.NodeFn4<any, any, any, any, T>, args: any[]): when.Promise<T>;
+    function apply<T>(fn: _.NodeFn5<any, any, any, any, any, T>, args: any[]): when.Promise<T>;
 
 
     function liftAll(srcApi: any, transform?: (destApi: any, liftedFunc: Function, name: string) => any, destApi?: any): any;
 
 
-    function call<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): when.Promise<TResult>;
-
-    function call<TArg1, TResult>(fn: (arg1: TArg1, callback: (err: any, result: TResult) => void) => void, arg1: TArg1): when.Promise<TResult>;
-    function call<TArg1, TResult>(fn: (arg1: TArg1, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>): when.Promise<TResult>;
-
-    function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: TArg2): when.Promise<TResult>;
-    function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: TArg2): when.Promise<TResult>;
-    function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: when.Promise<TArg2>): when.Promise<TResult>;
-    function call<TArg1, TArg2, TResult>(fn: (arg1: TArg1, arg2: TArg2, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>): when.Promise<TResult>;
-
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: TArg2, arg3: TArg3): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: TArg2, arg3: when.Promise<TArg3>): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: when.Promise<TArg2>, arg3: TArg3): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: TArg1, arg2: when.Promise<TArg2>, arg3: when.Promise<TArg3>): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: TArg2, arg3: TArg3): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: TArg2, arg3: when.Promise<TArg3>): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>, arg3: TArg3): when.Promise<TResult>;
-    function call<TArg1, TArg2, TArg3, TResult>(fn: (arg1: TArg1, arg2: TArg2, arg3: TArg3, callback: (err: any, result: TResult) => void) => void, arg1: when.Promise<TArg1>, arg2: when.Promise<TArg2>, arg3: when.Promise<TArg3>): when.Promise<TResult>;
-
-
-    function apply<TResult>(fn: (callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
-    function apply<TResult>(fn: (arg1: any, callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
-    function apply<TResult>(fn: (arg1: any, arg2: any, callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
-    function apply<TResult>(fn: (arg1: any, arg2: any, arg3: any, callback: (err: any, result: TResult) => void) => void, args: any[]): when.Promise<TResult>;
-
-
     function liftCallback<TArg>(callback: (err: any, arg: TArg) => void): (value: when.Promise<TArg>) => when.Promise<TArg>;