diff --git a/types/async/index.d.ts b/types/async/index.d.ts
index ebbcb495b76189..bf6144e40d9051 100644
--- a/types/async/index.d.ts
+++ b/types/async/index.d.ts
@@ -8,26 +8,28 @@
 //                 Dmitri Trofimov <https://github.com/Dmitri1337>
 //                 Etienne Rossignon <https://github.com/erossignon>
 //                 Lifeng Zhu <https://github.com/Juliiii>
+//                 Simon Chan <https://github.com/yume-chan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
 export as namespace async;
 
 export interface Dictionary<T> { [key: string]: T; }
-export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>;
+export type IterableCollection<T> = T[] | IterableIterator<T> | AsyncIterableIterator<T> | Dictionary<T>;
 
 export interface ErrorCallback<E = Error> { (err?: E | null): void; }
 export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
 export interface AsyncResultCallback<T, E = Error> { (err?: E | null, result?: T): void; }
+export interface AsyncResultExCallback<T, E = Error> { (err?: E | null, ...result: T[]): void; }
 export interface AsyncResultArrayCallback<T, E = Error> { (err?: E | null, results?: Array<T | undefined>): void; }
 export interface AsyncResultObjectCallback<T, E = Error> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
 
 export interface AsyncFunction<T, E = Error> { (callback: (err?: E | null, result?: T) => void): void; }
 export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...results: T[]) => void): void; }
 export interface AsyncIterator<T, E = Error> { (item: T, callback: ErrorCallback<E>): void; }
-export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
+export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number | string, callback: ErrorCallback<E>): void; }
 export interface AsyncResultIterator<T, R, E = Error> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncMemoIterator<T, R, E = Error> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncMemoIterator<T, R, E = Error> { (memo: R, item: T, callback: AsyncResultCallback<R, E>): void; }
 export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
 export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
@@ -56,7 +58,11 @@ export interface AsyncQueue<T> {
     running(): number;
     idle(): boolean;
     concurrency: number;
-    push<R, E = Error>(task: T | T[], callback?: AsyncResultCallback<R, E>): void;
+
+    push<R, E = Error>(task: T | T[], callback: AsyncResultCallback<R, E>): void;
+    push<R, E = Error>(task: T): Promise<R>;
+    push<R, E = Error>(task: T[]): Array<Promise<R>>;
+
     unshift<E = Error>(task: T | T[], callback?: ErrorCallback<E>): void;
     remove(filter: (node: DataContainer<T>) => boolean): void;
 
@@ -76,7 +82,9 @@ export interface AsyncQueue<T> {
     error(): Promise<void>;
     error(handler: (error: Error, task: T) => void): void;
 
-    unsaturated(): void;
+    unsaturated(handler: () => void): void;
+    unsaturated(): Promise<void>;
+
     buffer: number;
 }
 
@@ -114,143 +122,218 @@ export interface AsyncCargo {
 }
 
 // Collections
-export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback: ErrorCallback<E>): void;
+export function each<T, E = Error>(arr: T[], iterator: (item: T, callback: ErrorCallback<E>) => void): Promise<void>;
 export const eachSeries: typeof each;
-export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback: ErrorCallback<E>): void;
+export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>): Promise<void>;
 export const forEach: typeof each;
 export const forEachSeries: typeof each;
 export const forEachLimit: typeof eachLimit;
-export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback: ErrorCallback<E>): void;
+export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>): Promise<void>;
 export const forEachOfSeries: typeof forEachOf;
-export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback: ErrorCallback<E>): void;
+export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>): Promise<void>;
 export const eachOf: typeof forEachOf;
 export const eachOfSeries: typeof forEachOf;
 export const eachOfLimit: typeof forEachOfLimit;
-export function map<T, R, E = Error>(arr: T[] | IterableIterator<T> | Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R, E>, callback: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R, E>): Promise<R>;
 export const mapSeries: typeof map;
-export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback: AsyncResultArrayCallback<R, E>): void;
+export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>): Promise<R>;
 
 export function mapValuesLimit<T, R, E = Error>(
     obj: Dictionary<T>,
     limit: number,
     iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
     callback: AsyncResultObjectCallback<R, E>
-    ): void;
+): void;
+export function mapValuesLimit<T, R, E = Error>(
+    obj: Dictionary<T>,
+    limit: number,
+    iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
+): Promise<Dictionary<R>>;
 
 export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void): Promise<Dictionary<R>>;
 export const mapValuesSeries: typeof mapValues;
-export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
 export const filterSeries: typeof filter;
-export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<T[]>;
+export function groupBy<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, any, E>, callback: AsyncResultObjectCallback<T, E>): void;
+export function groupBy<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, any, E>): Promise<Dictionary<T[]>>;
+export function groupByLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, any, E>, callback: AsyncResultObjectCallback<T, E>): void;
+export function groupByLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, any, E>): Promise<Dictionary<T[]>>;
+export const groupBySeries: typeof groupBy;
 export const select: typeof filter;
 export const selectSeries: typeof filter;
 export const selectLimit: typeof filterLimit;
 export const reject: typeof filter;
 export const rejectSeries: typeof filter;
 export const rejectLimit: typeof filterLimit;
-export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
+export function reduce<T, R, E = Error>(arr: IterableCollection<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback: AsyncResultCallback<R, E>): void;
+export function reduce<T, R, E = Error>(arr: IterableCollection<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>): Promise<R>;
 export const inject: typeof reduce;
 export const foldl: typeof reduce;
 export const reduceRight: typeof reduce;
 export const foldr: typeof reduce;
-export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultCallback<T, E>): void;
+export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<T>;
 export const detectSeries: typeof detect;
-export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncResultCallback<T, E>): void;
+export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<T>;
 export const find: typeof detect;
 export const findSeries: typeof detect;
 export const findLimit: typeof detectLimit;
-export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function sortBy<T, V, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, V, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function sortBy<T, V, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, V, E>): Promise<T[]>;
+export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
+export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
 export const someSeries: typeof some;
-export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
+export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
 export const any: typeof some;
 export const anySeries: typeof someSeries;
 export const anyLimit: typeof someLimit;
-export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
+export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
 export const everySeries: typeof every;
-export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback: AsyncBooleanResultCallback<E>): void;
+export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>): Promise<boolean>;
 export const all: typeof every;
 export const allSeries: typeof every;
 export const allLimit: typeof everyLimit;
 
-export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback: AsyncResultArrayCallback<R, E>): void;
+export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>): Promise<R[]>;
+export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback: AsyncResultArrayCallback<R, E>): void;
+export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>): Promise<R>;
 export const concatSeries: typeof concat;
 
 // Control Flow
-export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
-export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
-export function whilst<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function during<E = Error>(test: (testCallback: AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
+export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultArrayCallback<T, E>): void;
+export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Promise<T[]>;
+export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback: AsyncResultObjectCallback<T, E>): void;
+export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>): Promise<Dictionary<T>>;
+export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultArrayCallback<T, E>): void;
+export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Promise<T[]>;
+export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback: AsyncResultObjectCallback<T, E>): void;
+export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>): Promise<Dictionary<T>>;
+export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback: AsyncResultArrayCallback<T, E>): void;
+export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number): Promise<T[]>;
+export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback: AsyncResultObjectCallback<T, E>): void;
+export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number): Promise<Dictionary<T>>;
+export function whilst<T, E = Error>(test: AsyncFunction<boolean>, fn: AsyncFunctionEx<T, E>, callback: AsyncResultExCallback<T>): void;
+export function whilst<T, E = Error>(test: AsyncFunction<boolean>, fn: AsyncFunctionEx<T, E>): Promise<T>;
+export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: Function, callback: AsyncResultExCallback<T, E>): void;
+export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: Function): Promise<T>;
+export const until: typeof whilst;
+export const doUntil: typeof doWhilst;
+export const during: typeof whilst;
+export const doDuring: typeof doWhilst;
 export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
-export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
+export function forever<E = Error>(next: (next: ErrorCallback<E>) => void): Promise<never>;
+export function waterfall<T, E = Error>(tasks: Function[], callback: AsyncResultCallback<T, E>): void;
+export function waterfall<T, E = Error>(tasks: Function[]): Promise<T>;
 export function compose(...fns: Function[]): Function;
 export function seq(...fns: Function[]): Function;
-export function applyEach(fns: Function[], ...argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+// applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+export function applyEach(fns: Function[], ...argsAndCallback: any[]): Function;
+// applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): Function;
 export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
 export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
 export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
 export function cargo<E = Error>(worker: (tasks: any[], callback: ErrorCallback<E>) => void, payload?: number): AsyncCargo;
-export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
-export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
-export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency: number, callback: AsyncResultCallback<R, E>): void;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number): Promise<R>;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback: AsyncResultCallback<R, E>): void;
+export function autoInject<E = Error>(tasks: any, callback: AsyncResultCallback<any, E>): void;
+export function autoInject<E = Error>(tasks: any): Promise<any>;
 
 export function retry<T, E = Error>(
     opts: number | {
-        times: number,
-        interval: number | ((retryCount: number) => number),
+        times?: number,
+        interval?: number | ((retryCount: number) => number),
+        errorFilter?: (error: Error) => boolean
+    },
+    task: AsyncFunctionEx<T>,
+    callback: AsyncResultExCallback<T, E>
+): void;
+export function retry<T, E = Error>(
+    task: AsyncFunctionEx<T>,
+    callback: AsyncResultExCallback<T, E>
+): void;
+export function retry<T, E = Error>(
+    opts: number | {
+        times?: number,
+        interval?: number | ((retryCount: number) => number),
         errorFilter?: (error: Error) => boolean
     },
-    task: (callback: AsyncResultCallback<T, E>, results: any) => void,
-    callback: AsyncResultCallback<any, E>
-    ): void;
+    task: AsyncFunctionEx<T>,
+): Promise<any>;
+export function retry<T, E = Error>(
+    task: AsyncFunctionEx<T>,
+): Promise<any>;
 
-export function retryable<T, E = Error>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
+export function retryable<T, R, E = Error>(opts: number | { times?: number, interval?: number }, task: Function): Function;
+export function retryable<T, R, E = Error>(task: Function): Function;
 export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any, E>;
 export function nextTick(callback: Function, ...args: any[]): void;
 export const setImmediate: typeof nextTick;
 
-export function reflect<T, E = Error>(fn: AsyncFunction<T, E>): (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
-export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: {error?: E, value?: T}) => void) => void>;
+export function reflect<T, E = Error>(fn: AsyncFunction<T, E>): (callback: (err: null, result: { error?: E, value?: T }) => void) => void;
+export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: { error?: E, value?: T }) => void) => void>;
 
 export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
 export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
 
 export function times<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function timesSeries<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function times<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>): Promise<T[]>;
 export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>): Promise<T[]>;
+export const timesSeries: typeof times;
 
-export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
-export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export const tryEach: typeof race;
 
+export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: ErrorCallback<E>) => void, callback: AsyncResultArrayCallback<R, E>): void;
+export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: ErrorCallback<E>) => void): Promise<R>;
+export function transform<T, R, E = Error>(arr: T[], acc: R, iteratee: (acc: R, item: T, key: number, callback: ErrorCallback<E>) => void, callback: AsyncResultCallback<R, E>): void;
+export function transform<T, R, E = Error>(arr: T[], acc: R, iteratee: (acc: R, item: T, key: number, callback: ErrorCallback<E>) => void): Promise<R>;
+
+export function transform<T, R, E = Error>(
+    arr: { [key: string]: T },
+    iteratee: (acc: { [key: string]: R }, item: T, key: string, callback: ErrorCallback<E>) => void,
+    callback: AsyncResultObjectCallback<R, E>
+): void;
 export function transform<T, R, E = Error>(
-    arr: {[key: string]: T},
-    iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
-    callback?: AsyncResultObjectCallback<T, E>
-    ): void;
+    arr: { [key: string]: T },
+    iteratee: (acc: { [key: string]: R }, item: T, key: string, callback: ErrorCallback<E>) => void,
+): Promise<Dictionary<R>>;
 
 export function transform<T, R, E = Error>(
-    arr: {[key: string]: T},
-    acc: {[key: string]: R},
-    iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
-    callback?: AsyncResultObjectCallback<T, E>
-    ): void;
+    arr: { [key: string]: T },
+    acc: R,
+    iteratee: (acc: R, item: T, key: string, callback: ErrorCallback<E>) => void,
+    callback: AsyncResultCallback<R, E>
+): void;
+export function transform<T, R, E = Error>(
+    arr: { [key: string]: T },
+    acc: R,
+    iteratee: (acc: R, item: T, key: string, callback: ErrorCallback<E>) => void,
+): Promise<R>;
 
 export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): void;
+export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Promise<T>;
 
 // Utils
 export function memoize(fn: Function, hasher?: Function): Function;
 export function unmemoize(fn: Function): Function;
-export function ensureAsync(fn: (... argsAndCallback: any[]) => void): Function;
+export function ensureAsync(fn: (...argsAndCallback: any[]) => void): Function;
 export function constant(...values: any[]): Function;
 export function asyncify(fn: Function): (...args: any[]) => any;
 export function wrapSync(fn: Function): Function;
diff --git a/types/async/test/index.ts b/types/async/test/index.ts
index 7516e491921b7a..327d0cdd39c287 100644
--- a/types/async/test/index.ts
+++ b/types/async/test/index.ts
@@ -9,7 +9,7 @@ declare var path: {
     exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
 };
 
-function funcStringCbErrBoolean(v: string, cb: (err: Error, res: boolean) => void) {}
+function funcStringCbErrBoolean(v: string, cb: (err: Error, res: boolean) => void) { }
 function callback() { }
 
 async.map(['file1', 'file2', 'file3'], fs.stat, (err: Error, results: fs.Stats[]) => { });
@@ -103,15 +103,15 @@ async.series([callback => { callback(undefined, 'one'); }, callback => { callbac
 async.series<string>([callback => { callback(undefined, 'one'); }, callback => { callback(undefined, 'two'); }], (err, results) => { });
 
 async.series({
-        one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
-        two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
-    },
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
+},
     (err, results) => { });
 
 async.series<number>({
-        one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
-        two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
-    },
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
+},
     (err, results) => { });
 
 async.times(5, (n, next) => { next(undefined as any, n); }, (err, results) => { console.log(results); });
@@ -119,38 +119,38 @@ async.times(5, (n, next) => { next(undefined as any, n); }, (err, results) => {
 async.timesSeries(5, (n, next) => { next(undefined as any, n); }, (err, results) => { console.log(results); });
 
 async.parallel([
-        callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); },
-        callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); }
-    ],
+    callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); },
+    callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); }
+],
     (err, results) => { });
 
 async.parallel<string>([
-        callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); },
-        callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); }
-    ],
+    callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); },
+    callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); }
+],
     (err, results) => { });
 
 async.parallel({
-        one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
-        two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
-    },
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
+},
     (err, results) => { });
 
 async.parallel<number>({
-        one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
-        two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
-    },
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
+},
     (err, results) => { });
 
 async.parallelLimit({
-        one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
-        two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
-    },
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
+},
     2,
     (err, results) => { }
 );
 
-function whileFn(callback: any) {
+function whileFn(callback: (err: Error | null, result: number) => void) {
     setTimeout(() => callback(null, ++count), 1000);
 }
 
@@ -164,14 +164,14 @@ async.doWhilst(whileFn, doWhileTest, err => { });
 async.doUntil(whileFn, doWhileTest, err => { });
 
 async.during(testCallback => { testCallback(new Error(), false); }, callback => { callback(); }, error => { console.log(error); });
-async.doDuring(callback => { callback(); }, testCallback => { testCallback(new Error(), false); }, error => { console.log(error); });
+async.doDuring(callback => { callback(); }, (testCallback: (err: Error | null, truth: boolean) => void) => { testCallback(new Error(), false); }, error => { console.log(error); });
 async.forever(errBack => { errBack(new Error("Not going on forever.")); }, error => { console.log(error); });
 
 async.waterfall([
-        (callback: any) => { callback(null, 'one', 'two'); },
-        (arg1: any, arg2: any, callback: any) => { callback(null, 'three'); },
-        (arg1: any, callback: any) => { callback(null, 'done'); }
-    ],
+    (callback: any) => { callback(null, 'one', 'two'); },
+    (arg1: any, arg2: any, callback: any) => { callback(null, 'three'); },
+    (arg1: any, callback: any) => { callback(null, 'done'); }
+],
     (err, result) => { });
 
 const q = async.queue<any>((task: any, callback: (err?: Error, msg?: string) => void) => {
@@ -184,7 +184,7 @@ q.drain(() => { console.log('all items have been processed'); });
 q.push({ name: 'foo' });
 q.push({ name: 'bar' }, err => { console.log('finished processing bar'); });
 q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], err => { console.log('finished processing bar'); });
-q.push<string>({name: 'foo'}, (err, msg) => { console.log(`foo finished with a message "${msg!}"`); });
+q.push<string>({ name: 'foo' }, (err, msg) => { console.log(`foo finished with a message "${msg!}"`); });
 
 q.unshift({ name: 'foo' });
 q.unshift({ name: 'bar' }, err => { console.log('finished processing bar'); });
@@ -225,7 +225,7 @@ q2.push('testRemovalTask');
 q2.remove(x => x.data === 'testTaskRemoval');
 
 if (q2Length !== q2.length()) {
-  console.log('warning: Failed to remove a task from queue.');
+    console.log('warning: Failed to remove a task from queue.');
 }
 
 const aq = async.queue<number, number>((level: number, callback: (error?: Error, newLevel?: number) => void) => {
@@ -243,7 +243,7 @@ const q3 = async.queue<string>((task: string, callback: ErrorCallback) => {
 }, 1);
 
 q3.error((error, task) => {
-    console.log('task: ' +  task);
+    console.log('task: ' + task);
     console.log('error: ' + error);
 });
 
@@ -277,15 +277,15 @@ async.auto({
 });
 
 async.auto({
-        get_data: (callback: AsyncResultCallback<any>) => { },
-        make_folder: (callback: AsyncResultCallback<any>) => { },
+    get_data: (callback: AsyncResultCallback<any>) => { },
+    make_folder: (callback: AsyncResultCallback<any>) => { },
 
-        // arrays with different types are not accepted by TypeScript.
-        write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback<any>) => { callback(null, filename); }) as any],
+    // arrays with different types are not accepted by TypeScript.
+    write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback<any>) => { callback(null, filename); }) as any],
 
-        // arrays with different types are not accepted by TypeScript.
-        email_link: ['write_file', ((callback: AsyncResultCallback<any>, results: any) => { }) as any]
-    },
+    // arrays with different types are not accepted by TypeScript.
+    email_link: ['write_file', ((callback: AsyncResultCallback<any>, results: any) => { }) as any]
+},
     (err, results) => { console.log('finished auto'); }
 );
 
@@ -297,30 +297,31 @@ interface A {
 }
 
 async.auto<A>({
-        get_data: (callback: AsyncResultCallback<any>) => { },
-        make_folder: (callback: AsyncResultCallback<any>) => { },
+    get_data: (callback: AsyncResultCallback<any>) => { },
+    make_folder: (callback: AsyncResultCallback<any>) => { },
 
-        // arrays with different types are not accepted by TypeScript.
-        write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback<any>) => { callback(null, filename); }) as any],
+    // arrays with different types are not accepted by TypeScript.
+    write_file: ['get_data', 'make_folder', ((callback: AsyncResultCallback<any>) => { callback(null, filename); }) as any],
 
-        // arrays with different types are not accepted by TypeScript.
-        email_link: ['write_file', ((callback: AsyncResultCallback<any>, results: any) => { }) as any]
-    },
+    // arrays with different types are not accepted by TypeScript.
+    email_link: ['write_file', ((callback: AsyncResultCallback<any>, results: any) => { }) as any]
+},
     1,
     (err, results) => { console.log('finished auto'); }
 );
 
-async.retry(3, (callback, results) => { }, (err, result) => { });
-async.retry({ times: 3, interval: 200 }, (callback, results) => { }, (err, result) => { });
-async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, (callback, results) => { }, (err, result) => { });
-async.retry({ times: 3, interval: 200, errorFilter: (err) => true }, (callback, results) => { }, (err, result) => { });
+async.retry(3, (callback) => { }, (err, result) => { });
+async.retry({ times: 3, interval: 200 }, (callback) => { }, (err, result) => { });
+async.retry({ times: 3, interval: (retryCount) => 200 * retryCount }, (callback) => { }, (err, result) => { });
+async.retry({ times: 3, interval: 200, errorFilter: (err) => true }, (callback) => { }, (err, result) => { });
 
 async.parallel([
-        (callback: (err: Error, val: string) => void) => { },
-        callback => { }
-    ],
-    (err: Error, results: string[]) => { async.series([callback => { }, function email_link(callback) { }]);
-});
+    (callback: (err: Error, val: string) => void) => { },
+    callback => { }
+],
+    (err: Error, results: string[]) => {
+        async.series([callback => { }, function email_link(callback) { }]);
+    });
 
 async.parallel([
     async.apply(fs.writeFile, 'testfile1', 'test1'),
@@ -360,7 +361,7 @@ async.each<number>(
             console.log(`async.each: ${val}`);
             next();
         },
-        500);
+            500);
     },
     (err?: Error) => { console.log("async.each: done."); }
 );
@@ -386,7 +387,7 @@ async.eachLimit<number>(
             console.log(`async.eachLimit: ${val}`);
             next();
         },
-        500);
+            500);
     },
     (err?: Error) => { console.log("async.eachLimit: done."); }
 );
@@ -465,12 +466,12 @@ async.mapLimit<number, string>(
     { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 },
     2,
     (val: number, next: AsyncResultCallback<string>) => {
-    setTimeout(
-        () => {
-            console.log(`async.mapLimit: ${val}`);
-            next(undefined as any, val.toString());
-        },
-        500);
+        setTimeout(
+            () => {
+                console.log(`async.mapLimit: ${val}`);
+                next(undefined as any, val.toString());
+            },
+            500);
     },
     (err: Error, results: string[]) => { console.log("async.mapLimit: done with results", results); }
 );
@@ -584,24 +585,46 @@ async.some<number>(
 // timeout
 
 function myFunction1(foo: any, callback: (err?: Error, result?: any) => void): void {
-	console.log(`async.timeout 1 ${foo}`);
-	callback(undefined, foo);
+    console.log(`async.timeout 1 ${foo}`);
+    callback(undefined, foo);
 }
 const wrapped1 = async.timeout(myFunction1, 1000);
 wrapped1({ bar: 'bar' }, (err: Error, data: any) => { console.log(`async.timeout 1 end ${data}`); });
 
 function myFunction2(callback: (err?: Error, result?: any) => void): void {
-	console.log(`async.timeout 2`);
-	callback(undefined, { bar: 'bar' });
+    console.log(`async.timeout 2`);
+    callback(undefined, { bar: 'bar' });
 }
 
 const wrapped2 = async.timeout(myFunction2, 1000);
 wrapped2((err: Error, data: any) => { console.log(`async.timeout 2 end ${data}`); });
 
 function myFunction3(callback: (err?: Error, result?: any) => void): void {
-	console.log(`async.timeout 3`);
-	callback(undefined, { bar: 'bar' });
+    console.log(`async.timeout 3`);
+    callback(undefined, { bar: 'bar' });
 }
 
 const wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' });
 wrapped3((err: Error, data: any) => { console.log(`async.timeout 3 end ${data}`); });
+
+async.race([
+    (callback) => {
+        callback(null, 42);
+    },
+    (callback) => {
+        callback(null, 'foo');
+    }
+], (err, result) => {
+    console.log(result);
+});
+
+async.race([
+    (callback) => {
+        callback(null, 42);
+    },
+    (callback) => {
+        callback(null, 'foo');
+    }
+]).then(result => {
+    console.log(result);
+});
diff --git a/types/async/tsconfig.json b/types/async/tsconfig.json
index 153a5471fbd461..fe0e1074b86b69 100644
--- a/types/async/tsconfig.json
+++ b/types/async/tsconfig.json
@@ -23,4 +23,4 @@
         "test/explicit.ts",
         "test/es6-generators.ts"
     ]
-}
\ No newline at end of file
+}