From f713855f033bef0552c3bfc5202fcb1ddc90f3c8 Mon Sep 17 00:00:00 2001
From: Andy <anhans@microsoft.com>
Date: Tue, 26 Sep 2017 08:36:27 -0700
Subject: [PATCH] async: Convert to module (#19870)

---
 types/async/index.d.ts             | 287 ++++++++++++++---------------
 types/async/test/es6-generators.ts |   2 +-
 types/async/test/index.ts          |   2 +
 types/async/tslint.json            |  33 ++++
 types/i2c-bus/i2c-bus-tests.ts     |   3 +-
 5 files changed, 177 insertions(+), 150 deletions(-)
 create mode 100644 types/async/tslint.json

diff --git a/types/async/index.d.ts b/types/async/index.d.ts
index 139689ea2f..f443ebf627 100644
--- a/types/async/index.d.ts
+++ b/types/async/index.d.ts
@@ -3,25 +3,27 @@
 // Definitions by: Boris Yankov <https://github.com/borisyankov>, Arseniy Maximov <https://github.com/kern0>, Joe Herman <https://github.com/Penryn>, Angus Fenying <https://github.com/fenying>, Pascal Martin <https://github.com/pascalmartin>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T; }
+export as namespace async;
 
-interface ErrorCallback<T> { (err?: T): void; }
-interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
-interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
-interface AsyncResultArrayCallback<T, E> { (err?: E, results?: (T | undefined)[]): void; }
-interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
+export interface Dictionary<T> { [key: string]: T; }
 
-interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
-interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
-interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
-interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
+export interface ErrorCallback<T> { (err?: T): void; }
+export interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
+export interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
+export interface AsyncResultArrayCallback<T, E> { (err?: E, results?: (T | undefined)[]): void; }
+export interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
 
-interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-interface AsyncVoidFunction<E> { (callback: ErrorCallback<E>): void; }
+export interface AsyncFunction<T, E> { (callback: (err?: E, result?: 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; }
+export interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
-interface AsyncQueue<T> {
+export interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+export interface AsyncVoidFunction<E> { (callback: ErrorCallback<E>): void; }
+
+export interface AsyncQueue<T> {
     length(): number;
     started: boolean;
     running(): number;
@@ -48,7 +50,7 @@ interface AsyncQueue<T> {
     buffer: number;
 }
 
-interface AsyncPriorityQueue<T> {
+export interface AsyncPriorityQueue<T> {
     length(): number;
     concurrency: number;
     started: boolean;
@@ -73,7 +75,7 @@ interface AsyncPriorityQueue<T> {
     buffer: number;
 }
 
-interface AsyncCargo {
+export interface AsyncCargo {
     length(): number;
     payload?: number;
     push(task: any, callback? : Function): void;
@@ -87,142 +89,133 @@ interface AsyncCargo {
     kill(): void;
 }
 
-interface Async {
+// Collections
+export function each<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function each<T, E>(arr: Dictionary<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export const eachSeries: typeof each;
+export function eachLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function eachLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export const forEach: typeof each;
+export const forEachSeries: typeof each;
+export const forEachLimit: typeof eachLimit;
+export function forEachOf<T, E>(obj: T[] | IterableIterator<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOf<T, E>(obj: Dictionary<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export const forEachOfSeries: typeof forEachOf;
+export function forEachOfLimit<T, E>(obj: T[] | IterableIterator<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOfLimit<T, E>(obj: Dictionary<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export const eachOf: typeof forEachOf;
+export const eachOfSeries: typeof forEachOf;
+export const eachOfLimit: typeof forEachOfLimit;
+export function map<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export const mapSeries: typeof map;
+export function mapLimit<T, R, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function mapLimit<T, R, E>(arr: Dictionary<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function mapValuesLimit<T, R, E>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapValues<T, R, E>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export const mapValuesSeries: typeof mapValues;
+export function filter<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filter<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export const filterSeries: typeof filter;
+export function filterLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filterLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+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>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
+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>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detect<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export const detectSeries: typeof detect;
+export function detectLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detectLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export const find: typeof detect;
+export const findSeries: typeof detect;
+export const findLimit: typeof detectLimit;
+export function sortBy<T, V, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function some<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function some<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export const someSeries: typeof some;
+export function someLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function someLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export const any: typeof some;
+export const anySeries: typeof someSeries;
+export const anyLimit: typeof someLimit;
+export function every<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function every<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export const everySeries: typeof every;
+export function everyLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function everyLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export const all: typeof every;
+export const allSeries: typeof every;
+export const allLimit: typeof everyLimit;
 
-    // Collections
-    each<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
-    each<T, E>(arr: Dictionary<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachSeries: typeof async.each;
-    eachLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
-    forEach: typeof async.each;
-    forEachSeries: typeof async.each;
-    forEachLimit: typeof async.eachLimit;
-    forEachOf<T, E>(obj: T[] | IterableIterator<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
-    forEachOf<T, E>(obj: Dictionary<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
-    forEachOfSeries: typeof async.forEachOf;
-    forEachOfLimit<T, E>(obj: T[] | IterableIterator<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
-    forEachOfLimit<T, E>(obj: Dictionary<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachOf: typeof async.forEachOf;
-    eachOfSeries: typeof async.forEachOf;
-    eachOfLimit: typeof async.forEachOfLimit;
-    map<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-    map<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-    mapSeries: typeof async.map;
-    mapLimit<T, R, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-    mapLimit<T, R, E>(arr: Dictionary<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-    mapValuesLimit<T, R, E>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
-    mapValues<T, R, E>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
-    mapValuesSeries: typeof async.mapValues;
-    filter<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-    filter<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-    filterSeries: typeof async.filter;
-    filterLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-    filterLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-    select: typeof async.filter;
-    selectSeries: typeof async.filter;
-    selectLimit: typeof async.filterLimit;
-    reject: typeof async.filter;
-    rejectSeries: typeof async.filter;
-    rejectLimit: typeof async.filterLimit;
-    reduce<T, R, E>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
-    inject: typeof async.reduce;
-    foldl: typeof async.reduce;
-    reduceRight: typeof async.reduce;
-    foldr: typeof async.reduce;
-    detect<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
-    detect<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
-    detectSeries: typeof async.detect;
-    detectLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
-    detectLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
-    find: typeof async.detect;
-    findSeries: typeof async.detect;
-    findLimit: typeof async.detectLimit;
-    sortBy<T, V, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-    some<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    some<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    someSeries: typeof async.some;
-    someLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    someLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    any: typeof async.some;
-    anySeries: typeof async.someSeries;
-    anyLimit: typeof async.someLimit;
-    every<T, E>(arr: T[] | IterableIterator<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    every<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    everySeries: typeof async.every;
-    everyLimit<T, E>(arr: T[] | IterableIterator<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    everyLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
-    all: typeof async.every;
-    allSeries: typeof async.every;
-    allLimit: typeof async.everyLimit;
+export function concat<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concat<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export const concatSeries: typeof concat;
 
-    concat<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
-    concat<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
-    concatSeries: typeof async.concat;
+// Control Flow
+export function series<T, E>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
+export function series<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+export function parallel<T, E>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+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 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 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;
+export function waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T, E | Error>): void;
+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.
+export function queue<T, E>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
+export function queue<T, R, E>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
+export function priorityQueue<T, E>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
+export function cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
+export function auto<E>(tasks: any, concurrency?: number, callback?: AsyncResultCallback<any, E>): void;
+export function autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
+export function retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
+export function retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
+export function retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
+export function apply<E>(fn: Function, ...args: any[]): AsyncFunction<any,E | Error>;
+export function nextTick(callback: Function, ...args: any[]): void;
+export const setImmediate: typeof nextTick;
 
-    // Control Flow
-    series<T, E>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
-    series<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-    parallel<T, E>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
-    parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-    parallelLimit<T, E>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
-    parallelLimit<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
-    whilst<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-    doWhilst<E>(fn: AsyncVoidFunction<E>, test: () => boolean, callback: ErrorCallback<E>): void;
-    until<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-    doUntil<E>(fn: AsyncVoidFunction<E>, test: () => boolean, callback: ErrorCallback<E>): void;
-    during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-    doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
-    forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
-    waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T, E | Error>): void;
-    compose(...fns: Function[]): Function;
-    seq(...fns: Function[]): Function;
-    applyEach(fns: Function[], argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-    applyEachSeries(fns: Function[], argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-    queue<T, E>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
-    queue<T, R, E>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
-    priorityQueue<T, E>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
-    cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
-    auto<E>(tasks: any, concurrency?: number, callback?: AsyncResultCallback<any, E>): void;
-    autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-    retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
-    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
-    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
-    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E | Error>;
-    nextTick(callback: Function, ...args: any[]): void;
-    setImmediate: typeof async.nextTick;
+export function reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+export function reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
 
-    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
-    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
+export function timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
+export function timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
 
-    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
-    timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
+export function times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
-    times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-    timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-    timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E>(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>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 
-    transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
-    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E>(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;
 
-    transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
-    transform<T, R, E>(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;
+export function race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
 
-    race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
-
-    // Utils
-    memoize(fn: Function, hasher?: Function): Function;
-    unmemoize(fn: Function): Function;
-    ensureAsync(fn: (... argsAndCallback: any[]) => void): Function;
-    constant(...values: any[]): Function;
-    asyncify(fn: Function): Function;
-    wrapSync(fn: Function): Function;
-    log(fn: Function, ...arguments: any[]): void;
-    dir(fn: Function, ...arguments: any[]): void;
-}
-
-declare var async: Async;
-
-declare module "async" {
-    export = async;
-}
+// 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 constant(...values: any[]): Function;
+export function asyncify(fn: Function): Function;
+export function wrapSync(fn: Function): Function;
+export function log(fn: Function, ...args: any[]): void;
+export function dir(fn: Function, ...args: any[]): void;
diff --git a/types/async/test/es6-generators.ts b/types/async/test/es6-generators.ts
index 2a7328a09a..b67e7daad7 100644
--- a/types/async/test/es6-generators.ts
+++ b/types/async/test/es6-generators.ts
@@ -1,6 +1,6 @@
 function* collectionGenerator<T>(): IterableIterator<T> { }
 
-function funcMapIterator<T, E>(value: T, callback: AsyncResultCallback<T, E>) { }
+function funcMapIterator<T, E>(value: T, callback: async.AsyncResultCallback<T, E>) { }
 function funcMapComplete<T, E>(error: E, results: T[]) { }
 
 function booleanIterator<T>(v: T, cb: (err: Error, res: boolean) => void) { }
diff --git a/types/async/test/index.ts b/types/async/test/index.ts
index 60234a0ca4..821ccd0650 100644
--- a/types/async/test/index.ts
+++ b/types/async/test/index.ts
@@ -1,5 +1,7 @@
 /// <reference types="node" />
 
+import async = require("async");
+import { ErrorCallback, AsyncResultCallback, AsyncBooleanResultCallback, Dictionary } from "async";
 import fs = require("fs");
 import process = require("process");
 
diff --git a/types/async/tslint.json b/types/async/tslint.json
new file mode 100644
index 0000000000..b1ab4a96cc
--- /dev/null
+++ b/types/async/tslint.json
@@ -0,0 +1,33 @@
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // TODOs
+        "arrow-return-shorthand": false,
+        "array-type": false,
+        "ban-types": false,
+        "callable-types": false,
+        "comment-format": false,
+        "dt-header": false,
+        "max-line-length": false,
+        "no-consecutive-blank-lines": false,
+        "no-padding": false,
+        "no-unnecessary-generics": false,
+        "no-var-keyword": false,
+        "no-void-expression": false,
+        "object-literal-key-quotes": false,
+        "object-literal-shorthand": false,
+        "one-variable-per-declaration": false,
+        "only-arrow-functions": false,
+        "prefer-const": false,
+        "prefer-for-of": false,
+        "prefer-method-signature": false,
+        "prefer-template": false,
+        "semicolon": false,
+        "space-before-function-paren": false,
+        "space-within-parens": false,
+        "trim-file": false,
+        "typedef-whitespace": false,
+        "unified-signatures": false,
+        "whitespace": false
+    }
+}
diff --git a/types/i2c-bus/i2c-bus-tests.ts b/types/i2c-bus/i2c-bus-tests.ts
index 1e4c6c8bcb..599e7c6599 100644
--- a/types/i2c-bus/i2c-bus-tests.ts
+++ b/types/i2c-bus/i2c-bus-tests.ts
@@ -5,8 +5,7 @@
 // Tests taken from documentation samples.
 
 import { I2cBus, open, openSync } from "i2c-bus";
-import * as asnc from "async";
-
+import * as async from "async";
 
 function toCelsius(rawTemp: number): number {
     const halfDegrees = ((rawTemp & 0xff) << 1) + (rawTemp >> 15);