diff --git a/async/index.d.ts b/async/index.d.ts
index e3fbe7e5129bce..62e047b2095d74 100644
--- a/async/index.d.ts
+++ b/async/index.d.ts
@@ -6,17 +6,16 @@
 interface Dictionary<T> { [key: string]: T; }
 
 interface ErrorCallback<T> { (err?: T): void; }
-interface AsyncWaterfallCallback<E> { (err: E, ...args: any[]): 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[]): void; }
-interface AsyncResultObjectCallback<T, E> { (err: E, results: Dictionary<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; }
 
 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, 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; }
 
 interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
@@ -76,7 +75,7 @@ interface AsyncPriorityQueue<T> {
 
 interface AsyncCargo {
     length(): number;
-    payload: number;
+    payload?: number;
     push(task: any, callback? : Function): void;
     push(task: any[], callback? : Function): void;
     saturated(): void;
@@ -175,7 +174,7 @@ interface Async {
     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>): 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.
@@ -186,29 +185,30 @@ interface Async {
     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>): void;
-    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
-    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
-    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E>;
+    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;
 
-    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: void, result: {error?: Error, value?: T}) => void) => void;
-    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: void, result: {error?: Error, 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)[];
 
-    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
-    timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
+    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>;
 
     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;
 
-    transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
-    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
-    transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): 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): 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;
 
-    race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<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;
+
+    race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
 
     // Utils
     memoize(fn: Function, hasher?: Function): Function;
@@ -226,4 +226,3 @@ declare var async: Async;
 declare module "async" {
     export = async;
 }
-
diff --git a/async/test/explicit.ts b/async/test/explicit.ts
index 80343cf6b16c25..b9ea9c84ed173e 100644
--- a/async/test/explicit.ts
+++ b/async/test/explicit.ts
@@ -1,44 +1,74 @@
 
 
-interface StringCallback { (err: Error, result: string): void; }
+interface StringCallback { (err?: Error, result?: string): void; }
 interface AsyncStringGetter { (callback: StringCallback): void; }
 
 var taskArray: AsyncStringGetter[] = [
     function (callback) {
         setTimeout(function () {
-            callback(null, 'one');
+            callback(undefined, 'one');
         }, 200);
     },
     function (callback) {
         setTimeout(function () {
-            callback(null, 'two');
+            callback(undefined, 'two');
         }, 100);
     },
 ];
 
-async.series(taskArray, function (err, results) { console.log(results[0].match(/o/)) });
-async.parallel(taskArray, function (err, results) { console.log(results[0].match(/o/)) });
-async.parallelLimit(taskArray, 3, function (err, results) { console.log(results[0].match(/o/)) });
+async.series(taskArray, function (err, results) {
+    if (results) {
+        let first = results[0];
+        if (first) {
+            console.log(first.match(/o/))
+        }
+    }
+});
+async.parallel(taskArray, function (err, results) {
+    if (results) {
+        let first = results[0];
+        if (first) {
+            console.log(first.match(/o/))
+        }
+    }
+});
+async.parallelLimit(taskArray, 3, function (err, results) {
+    if (results) {
+        let first = results[0];
+        if (first) {
+            console.log(first.match(/o/))
+        }
+    }
+});
 
 
 interface Lookup<T> { [key: string]: T; }
-interface NumberCallback { (err: Error, result: number): void; }
+interface NumberCallback { (err?: Error, result?: number): void; }
 interface AsyncNumberGetter { (callback: NumberCallback): void; }
 
 var taskDict: Lookup<AsyncNumberGetter> = {
     one: function(callback){
         setTimeout(function(){
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function(callback){
         setTimeout(function(){
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     }
 }
 
-async.series(taskDict, function(err, results) { console.log(results['one'].toFixed(1)) });
-async.parallel(taskDict, function(err, results) { console.log(results['one'].toFixed(1)) });
-async.parallelLimit(taskDict, 3, function(err, results) { console.log(results['one'].toFixed(1)) });
+async.series(taskDict, function(err, results) {
+    let one = results['one'];
+    console.log(one && one.toFixed(1))
+});
+async.parallel(taskDict, function(err, results) {
+    let one = results['one'];
+    console.log(one && one.toFixed(1))
+});
+async.parallelLimit(taskDict, 3, function(err, results) {
+    let one = results['one'];
+    console.log(one && one.toFixed(1))
+});
 
diff --git a/async/test/index.ts b/async/test/index.ts
index 8c6be303e4e8ea..b30ca4c7ba9302 100644
--- a/async/test/index.ts
+++ b/async/test/index.ts
@@ -350,9 +350,9 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
 });
 
 
-var aq = async.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
+var aq = async.queue<number, number, Error>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
     console.log('hello ' + level);
-    callback(null, level+1);
+    callback(undefined, level+1);
 });
 
 aq.push(1, function (err : Error, newLevel : number) {
@@ -807,9 +807,9 @@ async.some<number, Error>({
 
 // timeout
 
-function myFunction1(foo : any, callback: (err : Error, result : any) => void ) : void {
+function myFunction1(foo : any, callback: (err?: Error, result?: any) => void ) : void {
 	console.log(`async.timeout 1 ${foo}`);
-	return callback(null, foo);
+	return callback(undefined, foo);
 }
 var wrapped1 = async.timeout(myFunction1, 1000);
 wrapped1({ bar: 'bar' }, function(err : Error, data : any) {
@@ -817,9 +817,9 @@ wrapped1({ bar: 'bar' }, function(err : Error, data : any) {
 });
 
 
-function myFunction2(callback: (err : Error, result : any) => void ) : void {
+function myFunction2(callback: (err?: Error, result?: any) => void ) : void {
 	console.log(`async.timeout 2`);
-	return callback(null, { bar: 'bar' });
+	return callback(undefined, { bar: 'bar' });
 }
 
 var wrapped2 = async.timeout(myFunction2, 1000);
@@ -827,9 +827,9 @@ wrapped2( function(err : Error, data : any) {
     console.log(`async.timeout 2 end ${data}`);
 });
 
-function myFunction3(callback: (err : Error, result : any) => void ) : void {
+function myFunction3(callback: (err?: Error, result?: any) => void ) : void {
 	console.log(`async.timeout 3`);
-	return callback(null, { bar: 'bar' });
+	return callback(undefined, { bar: 'bar' });
 }
 
 var wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' });
diff --git a/async/tsconfig.json b/async/tsconfig.json
index 851293fccffac2..5b8f42c6d29a64 100644
--- a/async/tsconfig.json
+++ b/async/tsconfig.json
@@ -6,7 +6,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"
@@ -20,4 +20,4 @@
         "test/index.ts",
         "test/explicit.ts"
     ]
-}
\ No newline at end of file
+}