diff --git a/types/async/index.d.ts b/types/async/index.d.ts
index 80f2888a8b..f1b38e8130 100644
--- a/types/async/index.d.ts
+++ b/types/async/index.d.ts
@@ -15,6 +15,7 @@ export interface AsyncResultArrayCallback<T, E> { (err?: E, results?: (T | undef
 export interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
 
 export interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+export interface AsyncFunctionEx<T, E> { (callback: (err?: E, ...results: T[]) => void): void; }
 export interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
 export interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
 export interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
@@ -174,9 +175,9 @@ export function parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?
 export function parallelLimit<T, E>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
 export function parallelLimit<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
 export function whilst<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doWhilst<E>(fn: AsyncVoidFunction<E>, test: () => boolean, callback: ErrorCallback<E>): void;
+export function doWhilst<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
 export function until<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doUntil<E>(fn: AsyncVoidFunction<E>, test: () => boolean, callback: ErrorCallback<E>): void;
+export function doUntil<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
 export function during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
 export function doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
 export function forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
diff --git a/types/async/test/explicit.ts b/types/async/test/explicit.ts
index b9ea9c84ed..0c0e1a44ee 100644
--- a/types/async/test/explicit.ts
+++ b/types/async/test/explicit.ts
@@ -47,13 +47,13 @@ interface NumberCallback { (err?: Error, result?: number): void; }
 interface AsyncNumberGetter { (callback: NumberCallback): void; }
 
 var taskDict: Lookup<AsyncNumberGetter> = {
-    one: function(callback){
-        setTimeout(function(){
+    one: function(callback) {
+        setTimeout(function() {
             callback(undefined, 1);
         }, 200);
     },
-    two: function(callback){
-        setTimeout(function(){
+    two: function(callback) {
+        setTimeout(function() {
             callback(undefined, 2);
         }, 100);
     }
diff --git a/types/async/test/index.ts b/types/async/test/index.ts
index 821ccd0650..3c6c2f5dfe 100644
--- a/types/async/test/index.ts
+++ b/types/async/test/index.ts
@@ -239,16 +239,16 @@ async.parallelLimit({
 
 
 function whileFn(callback: any) {
-    count++;
-    setTimeout(callback, 1000);
+    setTimeout(() => callback(null, ++count), 1000);
 }
 
 function whileTest() { return count < 5; }
+function doWhileTest(count: number) { return count < 5; }
 var count = 0;
 async.whilst(whileTest, whileFn, function (err) { });
 async.until(whileTest, whileFn, function (err) { });
-async.doWhilst(whileFn, whileTest, function (err) { });
-async.doUntil(whileFn, whileTest, function (err) { });
+async.doWhilst(whileFn, doWhileTest, function (err) { });
+async.doUntil(whileFn, doWhileTest, function (err) { });
 
 async.during(function (testCallback) { testCallback(new Error(), false); }, function (callback) { callback() }, function (error) { console.log(error) });
 async.doDuring(function (callback) { callback() }, function (testCallback) { testCallback(new Error(), false); }, function (error) { console.log(error) });