Merge branch 'types-2.0' of https://github.com/DefinitelyTyped/DefinitelyTyped into types-2.0

.gitignore

@@ -35,5 +35,5 @@ node_modules
 
 .sublimets
 .settings/launch.json
-
 .vscode
+yarn.lock

.travis.yml

@@ -1,6 +1,6 @@
 language: node_js
 node_js:
-  - 4
+  - 6.9.1
 
 sudo: false
 

CONTRIBUTORS.md

@@ -401,6 +401,7 @@ This document generated by [dt-contributors-generator](https://github.com/vvakam
 * [:link:](egg.js/egg.js.d.ts) [Egg.js](https://github.com/mikeflynn/egg.js) by [Markus Peloso](https://github.com/ToastHawaii)
 * [:link:](ejs-locals/ejs-locals.d.ts) [ejs-locals](https://github.com/randometc/ejs-locals) by [jt000](https://github.com/jt000)
 * [:link:](ejs/ejs.d.ts) [ejs.js](http://ejs.co) by [Ben Liddicott](https://github.com/benliddicott/DefinitelyTyped)
+* [:link:](ejson/ejson.d.ts) [ejson](https://www.npmjs.com/package/ejson) by [Shantanu Bhadoria](https://github.com/shantanubhadoria)
 * [:link:](elasticsearch/elasticsearch.d.ts) [elasticsearch](https://www.elastic.co) by [Casper Skydt](https://github.com/CasperSkydt/DefinitelyTyped), [Blake Smith](https://github.com/bfsmith/DefinitelyTyped)
 * [:link:](jquery.elang/jquery.elang.d.ts) [eLang](https://github.com/sumegizoltan/ELang) by [Zoltan Sumegi](https://github.com/sumegizoltan)
 * [:link:](github-electron/github-electron.d.ts) [Electron](http://electron.atom.io) by [jedmao](https://github.com/jedmao), [rhysd](https://rhysd.github.io), [Milan Burda](https://github.com/miniak)
@@ -1189,7 +1190,7 @@ This document generated by [dt-contributors-generator](https://github.com/vvakam
 * [:link:](ng-stomp/ng-stomp.d.ts) [ngStomp](https://github.com/beevelop/ng-stomp) by [Lukasz Potapczuk](https://github.com/lpotapczuk)
 * [:link:](ngstorage/ngstorage.d.ts) [ngstorage](https://github.com/gsklee/ngStorage) by [Jakub Pistek](https://github.com/kubiq)
 * [:link:](nightmare/nightmare.d.ts) [Nightmare](https://github.com/segmentio/nightmare) by [horiuchi](https://github.com/horiuchi)
-* [:link:](noble/noble.d.ts) [noble](https://github.com/sandeepmistry/noble) by [Seon-Wook Park](https://github.com/swook), [Hans Bakker](https://github.com/wind-rider)
+* [:link:](noble/noble.d.ts) [noble](https://github.com/sandeepmistry/noble) by [Seon-Wook Park](https://github.com/swook), [Hans Bakker](https://github.com/wind-rider), [Shantanu Bhadoria](https://github.com/shantanubhadoria)
 * [:link:](nock/nock.d.ts) [nock](https://github.com/pgte/nock) by [bonnici](https://github.com/bonnici)
 * [:link:](node-imap/imap.d.ts) [node imap](https://github.com/mscdex/node-imap) by [Steve Fenton](https://github.com/Steve-Fenton)
 * [:link:](oauth2-server/oauth2-server.d.ts) [Node OAuth2 Server](https://github.com/thomseddon/node-oauth2-server) by [Robbie Van Gorkom](https://github.com/vangorra)

PULL_REQUEST_TEMPLATE.md

@@ -1,8 +1,16 @@
-case 1. Add a new type definition.
-- [ ] checked compilation succeeds with `--target es6` and `--noImplicitAny` options.
-- [ ] has correct [naming convention](http://definitelytyped.org/guides/contributing.html#naming-the-file)
-- [ ] has a [test file](http://definitelytyped.org/guides/contributing.html#tests) with the suffix of  `-tests.ts` or `-tests.tsx`.
+Please fill in this template.
 
-case 2. Improvement to existing type definition.
-- documentation or source code reference which provides context for the suggested changes.  url http://api.jquery.com/html .
-  - it has been reviewed by a DefinitelyTyped member.
+- [ ] Prefer to make your PR against the `types-2.0` branch.
+- [ ] The package does not provide its own types, and you can not add them.
+- [ ] Test the change in your own code.
+- [ ] Follow the advice from the [readme](https://github.com/DefinitelyTyped/DefinitelyTyped#make-a-pull-request).
+- [ ] Avoid [common mistakes](https://github.com/DefinitelyTyped/DefinitelyTyped#common-mistakes).
+
+If adding a new definition:
+- [ ] If this is for an NPM package, match the name. If not, do not conflict with the name of an NPM package.
+- [ ] Run `tsc` without errors.
+- [ ] Include the required [files](https://github.com/DefinitelyTyped/DefinitelyTyped#create-a-new-package) and header.
+
+If changing an existing definition:
+- [ ] Provide a URL to  documentation or source code which provides context for the suggested changes: <<url here>>
+- [ ] Increase the version number in the header if appropriate.

README.md

@@ -128,7 +128,7 @@ The `Project` link does not have to be to GitHub, but prefer linking to a source
         "module": "commonjs",
         "target": "es6",
         "noImplicitAny": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"
@@ -149,14 +149,18 @@ and you may also add the `"jsx"` compiler option if your library needs it.
 
 DefinitelyTyped members routinely monitor for new PRs, though keep in mind that the number of other PRs may slow things down.
 
+For a good example package, see [base64-js](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/types-2.0/base64-js).
 
 #### Common mistakes
 
 * First, follow advice from the [handbook](http://www.typescriptlang.org/docs/handbook/declaration-files/do-s-and-don-ts.html).
 * Formatting: Either use all tabs, or always use 4 spaces. Also, always use semicolons, and use egyptian braces.
 * `interface X {}`: An empty interface is essentially the `{}` type: it places no constraints on an object.
-* `interface Foo { new(): Foo }`:
+* `interface IFoo {}`: Don't add `I` to the front of an interface name.
+* `interface Foo { new(): Foo; }`:
     This defines a type of objects that are new-able. You probably want `declare class Foo { constructor(); }
+* `const Class: { new(): IClass; }`:
+    Prefer to use a class declaration `class Class { constructor(); }` instead of a new-able constant.
 * `namespace foo {}`:
     Do not add a namespace just so that the `import * as foo` syntax will work.
     If it is commonJs module with a single export, you should use the `import foo = require("foo")` syntax.
@@ -194,7 +198,7 @@ Changes to the `master` branch are also manually merged into the `types-2.0` bra
 
 #### I'm writing a definition that depends on another definition. Should I use `<reference types="" />` or an import?
 
-If the module you're referencing is an written as an external module (uses `export`), use an import.
+If the module you're referencing is an external module (uses `export`), use an import.
 If the module you're referenceing is an ambient module (uses `declare module`, or just declares globals), use `<reference types="" />`.
 
 #### What do I do about older versions of typings?
@@ -209,6 +213,10 @@ A `package.json` may be included for the sake of specifying dependencies. Here's
 We do not allow other fields, such as `"description"`, to be defined manually.
 Also, if you need to reference an older version of typings, you must do that by adding `"dependencies": { "@types/foo": "x.y.z" }` to the package.json.
 
+#### I notice some `tsconfig.json` are missing `"noImplicitAny": true` or `"strictNullChecks": true`.
+
+Then they are wrong. You can help by submitting a pull request to fix them.
+
 #### Definitions in types-2.0 seem written differently than in master.
 
 If you're targeting types-2.0, write it like the types-2.0 definitions.

ajv/index.d.ts

@@ -81,7 +81,7 @@ declare namespace Ajv {
         passContext?: boolean;
         loopRequired?: number;
         ownProperties?: boolean;
-        multipleOfPrecision?: boolean;
+        multipleOfPrecision?: boolean | number;
         errorDataPath?: string,
         messages?: boolean;
         beautify?: boolean;

angular-material/index.d.ts

@@ -336,6 +336,7 @@ declare module 'angular' {
             onRemoving?: Function;
             onDomRemoved?: Function;
             origin?: string | JQuery | Element;
+            onCloseSuccess?: ((panel: IPanelRef, closeReason: string) => any);
         }
 
         interface IPanelRef {
@@ -408,6 +409,16 @@ declare module 'angular' {
             interceptorTypes: {
                 CLOSE: string,
             };
+            closeReasons: {
+                CLICK_OUTSIDE: string,
+                ESCAPE: string,
+            };
+            absPosition: {
+                TOP:  string,
+                RIGHT: string,
+                BOTTOM: string,
+                LEFT: string,
+            };
         }
     }
 }

angular/angular-tests.ts

@@ -191,8 +191,25 @@ mod.controller({
     MyCtrl2: function() {},
     MyCtrl3: ['$fooService', function($fooService: any) { }]
 });
-mod.directive('name', <any>function ($scope: ng.IScope) { })
-mod.directive('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.directive('myDirectiveA', ($rootScope: ng.IRootScopeService) => {
+    return (scope, el, attrs) => {
+        let foo = 'none';
+        el.click(e => {
+            foo = e.type;
+            $rootScope.$apply();
+        });
+        scope.$watch(() => foo, () => el.text(foo));
+    };
+});
+mod.directive('myDirectiveB', ['$rootScope', function ($rootScope: ng.IRootScopeService) {
+    return {
+        link(scope, el, attrs) {
+            el.click(e => {
+                el.hide();
+            });
+        }
+    };
+}]);
 mod.directive({
     myFooDir: () => ({
         template: 'my-foo-dir.tpl.html'

angular/index.d.ts

@@ -1775,7 +1775,7 @@ declare namespace angular {
     ///////////////////////////////////////////////////////////////////////////
 
     interface IDirectiveFactory {
-        (...args: any[]): IDirective;
+        (...args: any[]): IDirective | IDirectiveLinkFn;
     }
 
     interface IDirectiveLinkFn {
@@ -1783,8 +1783,8 @@ declare namespace angular {
             scope: IScope,
             instanceElement: JQuery,
             instanceAttributes: IAttributes,
-            controller: {},
-            transclude: ITranscludeFunction
+            controller?: IController | IController[] | {[key: string]: IController},
+            transclude?: ITranscludeFunction
         ): void;
     }
 
@@ -1812,7 +1812,6 @@ declare namespace angular {
         controller?: string | Injectable<IControllerConstructor>;
         controllerAs?: string;
         /**
-         * @deprecated
          * Deprecation warning: although bindings for non-ES6 class controllers are currently bound to this before
          * the controller constructor is called, this use is now deprecated. Please place initialization code that
          * relies upon bindings inside a $onInit method on the controller, instead.

archiver/index.d.ts

@@ -18,29 +18,32 @@
 import * as FS from 'fs';
 import * as STREAM from 'stream';
 
-interface nameInterface {
-    name?: string;
-}
 
-interface Archiver extends STREAM.Transform {
-    pipe(writeStream: FS.WriteStream): void;
+declare function archiver(format: string, options?: archiver.Options): archiver.Archiver;
+
+declare namespace archiver {
+
+    export function create(format: string, options?: Options): Archiver;
+
+
+    export interface nameInterface {
+        name?: string;
+    }
+
+    export interface Archiver extends STREAM.Transform {
+        pipe(writeStream: FS.WriteStream): void;
         append(source: FS.ReadStream | Buffer | string, name: nameInterface): void;
 
         directory(dirpath: string, destpath: nameInterface | string): void;
         directory(dirpath: string, destpath: nameInterface | string, data: any | Function): void;
 
         bulk(mappings: any): void;
-    finalize(): void;
-}
+        finalize(): void;
+    }
 
-interface Options {
+    export interface Options {
 
-}
-
-declare function archiver(format: string, options?: Options): Archiver;
-
-declare namespace archiver {
-    function create(format: string, options?: Options): Archiver;
+    }
 }
 
 export = archiver;

array-foreach/array-foreach-tests.ts

@@ -0,0 +1,39 @@
+import arrayForEach = require('array-foreach');
+
+const array: Array<number> = [1, 2, 3, 4];
+const result: Array<number> = [];
+
+arrayForEach(array, (i: number) => {
+	result.push(i);
+});
+
+arrayForEach(array, (i: number, index: number) => {
+	result.push(i + index);
+});
+
+arrayForEach(array, (i: number, index: number, array: Array<number>) => {
+	result.push(array[i]);
+});
+
+const resultThis: Array<{i: number, that: string}> = [];
+
+arrayForEach(array, (i: number) => {
+	resultThis.push({
+		i: i,
+		that: this.that
+	});
+}, { that: 'jeff' });
+
+arrayForEach(array, (i: number, index: number) => {
+	resultThis.push({
+		i: i + index,
+		that: this.that
+	});
+}, { that: 'jeff' });
+
+arrayForEach(array, (i: number, index: number, array: Array<number>) => {
+	resultThis.push({
+		i: array[i],
+		that: this.that
+	});
+}, { that: 'jeff' });

array-foreach/index.d.ts

@@ -0,0 +1,21 @@
+// Type definitions for array-foreach
+// Project: https://www.npmjs.com/package/array-foreach
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+* Performs the specified action for each element in an array.
+* @param arr Array of items to iterate over
+* @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
+* @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+*/
+declare function forEach<T>(arr: Array<T>, callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => void, thisArg?: any): void;
+
+/**
+* Performs the specified action for each element in an array.
+* @param arr Nodelist of items to iterate over
+* @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
+* @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+*/
+declare function forEach<T extends Node>(arr: NodeListOf<T>, callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => void, thisArg?: any): void;
+export = forEach;

array-foreach/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "array-foreach-tests.ts"
+    ]
+}

async/async-tests.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 
 import fs = require("fs");
+import process = require("process");
 
-var path: {
-    exists: (path: string, callback?: (err: string, exists: boolean) => any) => void;
+declare var path: {
+    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
 };
 
 function callback() { }
@@ -33,8 +34,8 @@ async.series([
     function () { }
 ]);
 
-var data = [];
-function asyncProcess(item, callback) { }
+var data: any[] = [];
+function asyncProcess(item: any, callback: (err: Error, result: any) => void) { }
 async.map(data, asyncProcess, function (err, results) {
     console.log(results);
 });
@@ -49,11 +50,11 @@ var saveFile = function () { }
 async.each(openFiles, saveFile, function (err) { });
 async.eachSeries(openFiles, saveFile, function (err) { });
 
-var documents, requestApi;
+var documents: any, requestApi: any;
 async.eachLimit(documents, 20, requestApi, function (err) { });
 
 // forEachOf* functions. May accept array or object.
-function forEachOfIterator(item, key, forEachOfIteratorCallback) {
+function forEachOfIterator(item: string, key: string, forEachOfIteratorCallback: any) {
     console.log("ForEach: item=" + item + ", key=" + key);
     forEachOfIteratorCallback();
 }
@@ -64,9 +65,8 @@ async.forEachOfSeries(openFilesObj, forEachOfIterator, function (err) { });
 async.forEachOfLimit(openFiles, 2, forEachOfIterator, function (err) { });
 async.forEachOfLimit(openFilesObj, 2, forEachOfIterator, function (err) { });
 
-var process;
 var numArray = [1, 2, 3];
-function reducer(memo, item, callback) {
+function reducer(memo: any, item: any, callback: any) {
     process.nextTick(function () {
         callback(null, memo + item)
     });
@@ -103,20 +103,20 @@ async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) {
 
 async.series([
     function (callback) {
-        callback(null, 'one');
+        callback(undefined, 'one');
     },
     function (callback) {
-        callback(null, 'two');
+        callback(undefined, 'two');
     },
 ],
 function (err, results) { });
 
 async.series<string>([
     function (callback) {
-        callback(null, 'one');
+        callback(undefined, 'one');
     },
     function (callback) {
-        callback(null, 'two');
+        callback(undefined, 'two');
     },
 ],
 function (err, results) { });
@@ -124,12 +124,12 @@ function (err, results) { });
 async.series({
     one: function (callback) {
         setTimeout(function () {
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function (callback) {
         setTimeout(function () {
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     },
 },
@@ -138,25 +138,25 @@ function (err, results) { });
 async.series<number>({
     one: function (callback) {
         setTimeout(function () {
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function (callback) {
         setTimeout(function () {
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     },
 },
 function (err, results) { });
 
 async.times(5, function(n, next) {
-    next(null, n)
+    next(undefined as any, n)
 }, function(err, results) {
     console.log(results)
 })
 
 async.timesSeries(5, function(n, next) {
-    next(null, n)
+    next(undefined as any, n)
 }, function(err, results) {
     console.log(results)
 })
@@ -164,12 +164,12 @@ async.timesSeries(5, function(n, next) {
 async.parallel([
     function (callback) {
         setTimeout(function () {
-            callback(null, 'one');
+            callback(undefined, 'one');
         }, 200);
     },
     function (callback) {
         setTimeout(function () {
-            callback(null, 'two');
+            callback(undefined, 'two');
         }, 100);
     },
 ],
@@ -178,12 +178,12 @@ function (err, results) { });
 async.parallel<string>([
     function (callback) {
         setTimeout(function () {
-            callback(null, 'one');
+            callback(undefined, 'one');
         }, 200);
     },
     function (callback) {
         setTimeout(function () {
-            callback(null, 'two');
+            callback(undefined, 'two');
         }, 100);
     },
 ],
@@ -193,12 +193,12 @@ function (err, results) { });
 async.parallel({
     one: function (callback) {
         setTimeout(function () {
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function (callback) {
         setTimeout(function () {
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     },
 },
@@ -207,12 +207,12 @@ function (err, results) { });
 async.parallel<number>({
     one: function (callback) {
         setTimeout(function () {
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function (callback) {
         setTimeout(function () {
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     },
 },
@@ -221,12 +221,12 @@ async.parallel<number>({
 async.parallelLimit({
     one: function (callback) {
         setTimeout(function () {
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function (callback) {
         setTimeout(function () {
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     },
 },
@@ -235,7 +235,7 @@ async.parallelLimit({
 );
 
 
-function whileFn(callback) {
+function whileFn(callback: any) {
     count++;
     setTimeout(callback, 1000);
 }
@@ -258,19 +258,19 @@ async.forever(function (errBack) {
 );
 
 async.waterfall([
-    function (callback) {
+    function (callback: any) {
         callback(null, 'one', 'two');
     },
-    function (arg1, arg2, callback) {
+    function (arg1: any, arg2: any, callback: any) {
         callback(null, 'three');
     },
-    function (arg1, callback) {
+    function (arg1: any, callback: any) {
         callback(null, 'done');
     }
 ], function (err, result) { });
 
 
-var q = async.queue<any>(function (task: any, callback) {
+var q = async.queue<any>(function (task: any, callback: any) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -323,7 +323,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = async.queue<string>(function (task: string, callback) {
+var q2 = async.queue<string>(function (task: string, callback: any) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -358,26 +358,26 @@ var cargo = async.cargo(function (tasks, callback) {
 
 
 // add some items
-cargo.push({ name: 'foo' }, function (err) {
+cargo.push({ name: 'foo' }, function (err: Error) {
     console.log('finished processing foo');
 });
-cargo.push({ name: 'bar' }, function (err) {
+cargo.push({ name: 'bar' }, function (err: Error) {
     console.log('finished processing bar');
 });
-cargo.push({ name: 'baz' }, function (err) {
+cargo.push({ name: 'baz' }, function (err: Error) {
     console.log('finished processing baz');
 });
 
 var filename = '';
 async.auto({
-    get_data: function (callback) { },
-    make_folder: function (callback) { },
+    get_data: function (callback: any) { },
+    make_folder: function (callback: any) { },
     //arrays with different types are not accepted by TypeScript.
-    write_file: ['get_data', 'make_folder', <any>function (callback) {
+    write_file: ['get_data', 'make_folder', <any>function (callback: any) {
         callback(null, filename);
     }],
     //arrays with different types are not accepted by TypeScript.
-    email_link: ['write_file', <any>function (callback, results) { }]
+    email_link: ['write_file', <any>function (callback: any, results: any) { }]
 });
 
 async.retry(3, function (callback, results) { }, function (err, result) { });
@@ -411,13 +411,13 @@ async.parallel([
     },
 ]);
 
-var call_order = [];
+var call_order: string[] = [];
 async.nextTick(function () {
     call_order.push('two');
 });
 call_order.push('one');
 
-var slow_fn = function (name, callback) {
+var slow_fn = function (name: string, callback: any) {
     callback(null, 123);
 };
 var fn = async.memoize(slow_fn);
@@ -427,15 +427,369 @@ async.ensureAsync(function () { });
 async.constant(42);
 async.asyncify(function () { });
 
-async.log(function (name, callback) {
+async.log(function (name: any, callback: any) {
     setTimeout(function () {
         callback(null, 'hello ' + name);
     }, 0);
 }, "world"
     );
 
-async.dir(function (name, callback) {
+async.dir(function (name: string, callback: any) {
     setTimeout(function () {
         callback(null, { hello: name });
     }, 1000);
 }, "world");
+
+// each
+
+async.each<number>({
+    "a": 1,
+    "b": 2
+}, function(val: number, next: ErrorCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.each: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("async.each: done.");
+
+});
+
+async.eachSeries<number>({
+    "a": 1,
+    "b": 2
+}, function(val: number, next: ErrorCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.eachSeries: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("async.eachSeries: done.");
+
+});
+
+async.eachLimit<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3,
+    "d": 4,
+    "e": 5,
+    "f": 6
+}, 2, function(val: number, next: ErrorCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.eachLimit: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("async.eachLimit: done.");
+
+});
+
+// forEachOf/eachOf
+
+async.eachOf<number>({
+    "a": 1,
+    "b": 2
+}, function(val: number, key: string, next: ErrorCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.forEachOf/eachOf: ${key} = ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("async.forEachOf/eachOf: done.");
+
+});
+
+async.forEachOfSeries<number>({
+    "a": 1,
+    "b": 2
+}, function(val: number, key: string, next: ErrorCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.forEachOfSeries: ${key} = ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("async.forEachOfSeries: done.");
+
+});
+
+async.forEachOfLimit<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3,
+    "d": 4,
+    "e": 5,
+    "f": 6
+}, 2, function(val: number, key: string, next: ErrorCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.forEachOfLimit: ${key} = ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("async.forEachOfLimit: done.");
+
+});
+
+// map
+
+async.map<number, string>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: AsyncResultCallback<string>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.map: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("async.map: done with results", results);
+
+});
+
+async.mapSeries<number, string>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: AsyncResultCallback<string>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.mapSeries: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("async.mapSeries: done with results", results);
+
+});
+
+async.mapLimit<number, string>({
+    "a": 1,
+    "b": 2,
+    "c": 3,
+    "d": 4,
+    "e": 5,
+    "f": 6
+}, 2, function(val: number, next: AsyncResultCallback<string>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.mapLimit: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("async.mapLimit: done with results", results);
+
+});
+
+// mapValues
+
+async.mapValues<number, string>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.mapValues: ${key} = ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("async.mapValues: done with results", results);
+
+});
+
+async.mapValuesSeries<number, string>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.mapValuesSeries: ${key} = ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("async.mapValuesSeries: done with results", results);
+
+});
+
+// filter/select/reject
+
+async.filter<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: AsyncBooleanResultCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.filter/select: ${val}`);
+
+        next(undefined as any, val % 2 === 0);
+
+    }, 500);
+
+}, function(err: Error, results: number[]): void {
+
+    console.log("async.filter/select: done with results", results);
+
+});
+
+async.reject<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: AsyncBooleanResultCallback): void {
+
+    setTimeout(function(): void {
+
+        console.log(`async.reject: ${val}`);
+
+        next(undefined as any, val % 2 === 0);
+
+    }, 500);
+
+}, function(err: Error, results: number[]): void {
+
+    console.log("async.reject: done with results", results);
+
+});
+
+// concat
+
+async.concat<string, string>({
+    "a": "1",
+    "b": "2",
+    "c": "3"
+}, function(item: string, next: AsyncResultCallback<string[]>): void {
+
+    console.log(`async.concat: ${item}`);
+
+    next(undefined as any, [item, item, item]);
+
+}, function(err: Error, results: string[]) {
+
+    console.log("async.concat: done with results", results);
+
+});
+
+// detect/find
+
+async.detect<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(item: number, next: AsyncBooleanResultCallback): void {
+
+    console.log(`async.detect/find: ${item}`);
+
+    next(undefined as any, item > 1);
+
+}, function(err: Error, result: number) {
+
+    if (err) {
+
+        console.log(err);
+
+    } else {
+
+        console.log("async.detect/find: done with result", result);
+    }
+
+});
+
+// every/all
+
+async.every<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(item: number, next: AsyncBooleanResultCallback): void {
+
+    console.log(`async.every/all: ${item}`);
+
+    next(undefined as any, item > 0);
+
+}, function(err: Error, result: boolean) {
+
+    console.log("async.every/all: done with result", result);
+
+});
+
+// some/any
+
+async.some<number>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(item: number, next: AsyncBooleanResultCallback): void {
+
+    console.log(`async.some/any: ${item}`);
+
+    next(undefined as any, item > 2);
+
+}, function(err: Error, result: boolean) {
+
+    console.log("async.some/any: done with result", result);
+
+});

async/index.d.ts

@@ -1,11 +1,13 @@
 // Type definitions for Async 2.0.1
 // Project: https://github.com/caolan/async
-// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Arseniy Maximov <https://github.com/kern0>, Joe Herman <https://github.com/Penryn>
+// 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>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 interface Dictionary<T> { [key: string]: T; }
 
 interface ErrorCallback { (err?: Error): void; }
+interface AsyncWaterfallCallback { (err: Error, ...args: any[]): void; }
+interface AsyncBooleanResultCallback { (err: Error, truthValue: boolean): void; }
 interface AsyncResultCallback<T> { (err: Error, result: T): void; }
 interface AsyncResultArrayCallback<T> { (err: Error, results: T[]): void; }
 interface AsyncResultObjectCallback<T> { (err: Error, results: Dictionary<T>): void; }
@@ -15,7 +17,7 @@ interface AsyncIterator<T> { (item: T, callback: ErrorCallback): void; }
 interface AsyncForEachOfIterator<T> { (item: T, key: number|string, callback: ErrorCallback): void; }
 interface AsyncResultIterator<T, R> { (item: T, callback: AsyncResultCallback<R>): void; }
 interface AsyncMemoIterator<T, R> { (memo: R, item: T, callback: AsyncResultCallback<R>): void; }
-interface AsyncBooleanIterator<T> { (item: T, callback: (err: string, truthValue: boolean) => void): void; }
+interface AsyncBooleanIterator<T> { (item: T, callback: AsyncBooleanResultCallback): void; }
 
 interface AsyncWorker<T> { (task: T, callback: ErrorCallback): void; }
 interface AsyncVoidFunction { (callback: ErrorCallback): void; }
@@ -89,52 +91,74 @@ interface Async {
 
     // Collections
     each<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    eachSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    each<T>(arr: Dictionary<T>, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    eachSeries: typeof async.each;
     eachLimit<T>(arr: T[], limit: number, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    forEachOf(obj: any, iterator: (item: any, key: string|number, callback?: ErrorCallback) => void, callback: ErrorCallback): void;
+    eachLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    forEach: typeof async.each;
+    forEachSeries: typeof async.each;
+    forEachLimit: typeof async.eachLimit;
     forEachOf<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    forEachOfSeries(obj: any, iterator: (item: any, key: string|number, callback?: ErrorCallback) => void, callback: ErrorCallback): void;
-    forEachOfSeries<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    forEachOfLimit(obj: any, limit: number, iterator: (item: any, key: string|number, callback?: ErrorCallback) => void, callback: ErrorCallback): void;
+    forEachOf<T>(obj: Dictionary<T>, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    forEachOfSeries: typeof async.forEachOf;
     forEachOfLimit<T>(obj: T[], limit: number, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    map<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
-    mapSeries<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
-    mapLimit<T, R>(arr: T[], limit: number, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
-    mapValuesLimit<T, R>(obj: {[name: string]: T}, limit: number, iteratee: (value: string, key: T, callback: AsyncResultCallback<R>) => void, callback: AsyncResultCallback<R[]>): void;
-    mapValues<T, R>(obj: {[name: string]: T}, iteratee: (value: string, key: T, callback: AsyncResultCallback<R>) => void, callback: AsyncResultCallback<R[]>): void;
+    forEachOfLimit<T>(obj: Dictionary<T>, limit: number, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    eachOf: typeof async.forEachOf;
+    eachOfSeries: typeof async.forEachOf;
+    eachOfLimit: typeof async.forEachOfLimit;
+    map<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): void;
+    map<T, R>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): void;
+    mapSeries: typeof async.map;
+    mapLimit<T, R>(arr: T[], limit: number, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): void;
+    mapLimit<T, R>(arr: Dictionary<T>, limit: number, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): void;
+    mapValuesLimit<T, R>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R>) => void, callback: AsyncResultCallback<R[]>): void;
+    mapValues<T, R>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R>) => void, callback: AsyncResultCallback<R[]>): void;
     mapValuesSeries: typeof async.mapValues;
-    filter<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    select<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    filterSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    selectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    filterLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    selectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    reject<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    rejectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    rejectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): any;
-    reduce<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
-    inject<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
-    foldl<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
-    reduceRight<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncResultCallback<R>): any;
-    foldr<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncResultCallback<R>): any;
-    detect<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): any;
+    filter<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): void;
+    filter<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): void;
+    filterSeries: typeof async.filter;
+    filterLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): void;
+    filterLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): 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>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): void;
+    inject: typeof async.reduce;
+    foldl: typeof async.reduce;
+    reduceRight: typeof async.reduce;
+    foldr: typeof async.reduce;
+    detect<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): void;
+    detect<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): void;
+    detectSeries: typeof async.detect;
+    detectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): void;
+    detectLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): void;
     find: typeof async.detect;
-    detectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): any;
-    findSeries: typeof async.detectSeries;
-    detectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): any;
+    findSeries: typeof async.detect;
     findLimit: typeof async.detectLimit;
-    sortBy<T, V>(arr: T[], iterator: AsyncResultIterator<T, V>, callback?: AsyncResultArrayCallback<T>): any;
-    some<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
-    someLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
-    anyLimit: typeof async.someLimit;
-    someSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
+    sortBy<T, V>(arr: T[], iterator: AsyncResultIterator<T, V>, callback?: AsyncResultArrayCallback<T>): void;
+    some<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    some<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    someSeries: typeof async.some;
+    someLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    someLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    any: typeof async.some;
     anySeries: typeof async.someSeries;
-    any<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
-    every<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
-    everyLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
-    all<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
-    concat<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): any;
-    concatSeries<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): any;
+    anyLimit: typeof async.someLimit;
+    every<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    every<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    everySeries: typeof async.every;
+    everyLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    everyLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    all: typeof async.every;
+    allSeries: typeof async.every;
+    allLimit: typeof async.everyLimit;
+
+    concat<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): void;
+    concat<T, R>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): void;
+    concatSeries: typeof async.concat;
 
     // Control Flow
     series<T>(tasks: AsyncFunction<T>[], callback?: AsyncResultArrayCallback<T>): void;
@@ -143,14 +167,14 @@ interface Async {
     parallel<T>(tasks: Dictionary<AsyncFunction<T>>, callback?: AsyncResultObjectCallback<T>): void;
     parallelLimit<T>(tasks: Array<AsyncFunction<T>>, limit: number, callback?: AsyncResultArrayCallback<T>): void;
     parallelLimit<T>(tasks: Dictionary<AsyncFunction<T>>, limit: number, callback?: AsyncResultObjectCallback<T>): void;
-    whilst(test: () => boolean, fn: AsyncVoidFunction, callback: (err: any) => void): void;
-    doWhilst(fn: AsyncVoidFunction, test: () => boolean, callback: (err: any) => void): void;
-    until(test: () => boolean, fn: AsyncVoidFunction, callback: (err: any) => void): void;
-    doUntil(fn: AsyncVoidFunction, test: () => boolean, callback: (err: any) => void): void;
-    during(test: (testCallback : (error: Error, truth: boolean) => void) => void, fn: AsyncVoidFunction, callback: (err: any) => void): void;
-    doDuring(fn: AsyncVoidFunction, test: (testCallback: (error: Error, truth: boolean) => void) => void, callback: (err: any) => void): void;
-    forever(next: (errCallback : (err: Error) => void) => void, errBack: (err: Error) => void) : void;
-    waterfall(tasks: Function[], callback?: (err: Error, results?: any) => void): void;
+    whilst(test: () => boolean, fn: AsyncVoidFunction, callback: ErrorCallback): void;
+    doWhilst(fn: AsyncVoidFunction, test: () => boolean, callback: ErrorCallback): void;
+    until(test: () => boolean, fn: AsyncVoidFunction, callback: ErrorCallback): void;
+    doUntil(fn: AsyncVoidFunction, test: () => boolean, callback: ErrorCallback): void;
+    during(test: (testCallback : AsyncBooleanResultCallback) => void, fn: AsyncVoidFunction, callback: ErrorCallback): void;
+    doDuring(fn: AsyncVoidFunction, test: (testCallback: AsyncBooleanResultCallback) => void, callback: ErrorCallback): void;
+    forever(next: (next : ErrorCallback) => void, errBack: ErrorCallback) : void;
+    waterfall<T>(tasks: Function[], callback?: AsyncResultCallback<T>): 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.
@@ -158,19 +182,15 @@ interface Async {
     queue<T>(worker: AsyncWorker<T>, concurrency?: number): AsyncQueue<T>;
     priorityQueue<T>(worker: AsyncWorker<T>, concurrency: number): AsyncPriorityQueue<T>;
     cargo(worker : (tasks: any[], callback : ErrorCallback) => void, payload? : number) : AsyncCargo;
-    auto(tasks: any, concurrency?: number, callback?: (error: Error, results: any) => void): void;
-    autoInject(tasks: any, callback?: (error: Error, results: any) => void): void;
-    retry<T>(opts: number, task: (callback : AsyncResultCallback<T>, results: any) => void, callback: (error: Error, results: any) => void): void;
-    retry<T>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T>, results : any) => void, callback: (error: Error, results: any) => void): void;
+    auto(tasks: any, concurrency?: number, callback?: AsyncResultCallback<any>): void;
+    autoInject(tasks: any, callback?: AsyncResultCallback<any>): void;
+    retry<T>(opts: number, task: (callback : AsyncResultCallback<T>, results: any) => void, callback:  AsyncResultCallback<any>): void;
+    retry<T>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T>, results : any) => void, callback:  AsyncResultCallback<any>): void;
     retryable<T>(opts: number | {times: number, interval: number}, task: AsyncFunction<T>): AsyncFunction<T>;
     apply(fn: Function, ...arguments: any[]): AsyncFunction<any>;
     nextTick(callback: Function, ...args: any[]): void;
     setImmediate: typeof async.nextTick;
 
-    allLimit<T>(arr: T[], limit: number, iteratee: AsyncBooleanIterator<T>, cb?: (result: boolean) => any) : any;
-    everySeries<T>(arr: T[], iteratee: AsyncBooleanIterator<T>, cb?: (result: boolean) => any) : any
-    allSeries: typeof async.everySeries;
-
     reflect<T>(fn: AsyncFunction<T>) : (callback: (err: void, result: {error?: Error, value?: T}) => void) => void;
     reflectAll<T>(tasks: AsyncFunction<T>[]): ((callback: (err: void, result: {error?: Error, value?: T}) => void) => void)[];
 

async/tsconfig.json

@@ -2,8 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "target": "es6",
-        "noImplicitAny": false,
-        "strictNullChecks": false,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"

aws-sdk/index.d.ts

@@ -428,7 +428,8 @@ export declare class S3 {
     endpoint: Endpoint;
 
     getObject(params: s3.GetObjectRequest, callback?: (err: Error, data: any) => void): any;
-    putObject(params: s3.PutObjectRequest, callback: (err: Error, data: any) => void): void;
+    putObject(params: s3.PutObjectRequest, callback?: (err: Error, data: any) => void): any;
+    copyObject(params: s3.CopyObjectRequest, callback?: (err: Error, data: any) => void): any;
     deleteObject(params: s3.DeleteObjectRequest, callback: (err: Error, data: any) => void): void;
     headObject(params: s3.HeadObjectRequest, callback: (err: Error, data: any) => void): void;
     getSignedUrl(operation: string, params: any): string;
@@ -2303,6 +2304,40 @@ export declare module s3 {
         WebsiteRedirectLocation?: string;
     }
 
+    export interface CopyObjectRequest {
+      Bucket: string;
+      CopySource: string;
+      Key: string;
+      ACL?: string;
+      CacheControl?: string;
+      ContentDisposition?: string;
+      ContentEncoding?: string;
+      ContentLanguage?: string;
+      ContentType?: string;
+      CopySourceIfMatch?: string;
+      CopySourceIfModifiedSince?: any;
+      CopySourceIfNoneMatch?: string;
+      CopySourceIfUnmodifiedSince?: any;
+      CopySourceSSECustomerAlgorithm?: string;
+      CopySourceSSECustomerKey?: any;
+      CopySourceSSECustomerKeyMD5?: string;
+      Expires?: any;
+      GrantFullControl?: string;
+      GrantRead?: string;
+      GrantReadACP?: string;
+      GrantWriteACP?: string;
+      Metadata?: { [key: string]: string; };
+      MetadataDirective?: string;
+      RequestPayer?: string;
+      SSECustomerAlgorithm?: string;
+      SSECustomerKey?: any;
+      SSECustomerKeyMD5?: string;
+      SSEKMSKeyId?: string;
+      ServerSideEncryption?: string;
+      StorageClass?: string;
+      WebsiteRedirectLocation?: string;
+    }
+
     export interface GetObjectRequest {
         Bucket: string;
         IfMatch?: string;

aws4/aws4-tests.ts

@@ -0,0 +1,24 @@
+/// <reference path="./index.d.ts" />
+
+import * as aws4 from ".";
+
+let requestSigner = new aws4.RequestSigner({}, {});
+requestSigner.matchHost("");
+requestSigner.isSingleRegion();
+requestSigner.createHost();
+requestSigner.prepareRequest();
+requestSigner.sign();
+requestSigner.getDateTime();
+requestSigner.getDate();
+requestSigner.authHeader();
+requestSigner.signature();
+requestSigner.stringToSign();
+requestSigner.canonicalString();
+requestSigner.canonicalHeaders();
+requestSigner.signedHeaders();
+requestSigner.credentialString();
+requestSigner.defaultCredentials();
+requestSigner.parsePath();
+requestSigner.formatPath();
+
+aws4.sign({}, {});

aws4/index.d.ts

@@ -0,0 +1,33 @@
+// Type definitions for aws4 1.5.0
+// Project: https://github.com/mhart/aws4
+// Definitions by: Andrew Crites <https://github.com/ajcrites>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export class RequestSigner {
+    constructor(request?: any, credentials?: any);
+    request: any;
+    credentials: any;
+    service: any;
+    region: any;
+    isCodeCommitGit: any;
+
+    matchHost(host?: string): string;
+    isSingleRegion(): boolean;
+    createHost(): string;
+    prepareRequest(): void;
+    sign(): any;
+    getDateTime(): string;
+    getDate(): string;
+    authHeader(): string;
+    signature(): string;
+    stringToSign(): string;
+    canonicalString(): string;
+    canonicalHeaders(): string;
+    signedHeaders(): string;
+    credentialString(): string;
+    defaultCredentials(): any;
+    parsePath(): any;
+    formatPath(): string;
+}
+
+export function sign(options?: any, credentials?: any): RequestSigner;

aws4/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "aws4-tests.ts"
+    ]
+}

bootstrap-select/bootstrap-select-tests.ts

@@ -0,0 +1,40 @@
+/// <reference types="jquery"/>
+
+$(".selectpicker").selectpicker({
+    actionsBox: true,
+    container: "body",
+    countSelectedText: "counts > #",
+    deselectAllText: "test",
+    dropdownAlignRight: true,
+    dropupAuto: true,
+    header: "test",
+    hideDisabled: true,
+    iconBase: "fa",
+    liveSearch: true,
+    liveSearchNormalize: true,
+    liveSearchPlaceholder: "test",
+    liveSearchStyle: "contains",
+    maxOptions: 10,
+    maxOptionsText: "test",
+    mobile: true,
+    multipleSeparator: ", ",
+    noneSelectedText: "test",
+    selectAllText: "test",
+    selectedTextFormat: "values",
+    selectOnTab: true,
+    showContent: true,
+    showIcon: true,
+    showSubtext: true,
+    showTick: true,
+    size: "auto",
+    style: "test",
+    tickIcon: "test",
+    title: "test",
+    width: "auto"
+})
+
+$(".selectpicker").selectpicker("val", "foo")
+$(".selectpicker").selectpicker("val", ["foo", "bar"])
+$(".selectpicker").selectpicker("selectAll")
+$(".selectpicker").selectpicker("setStyle", "btn-large", "add")
+

bootstrap-select/index.d.ts

@@ -0,0 +1,44 @@
+// Type definitions for bootstrap-select v1.11.2
+// Project: https://silviomoreto.github.io/bootstrap-select/
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="jquery"/>
+
+interface BootstrapSelectOptions {
+    actionsBox?: boolean
+    container?: string | boolean
+    countSelectedText?: string | Function
+    deselectAllText?: string
+    dropdownAlignRight?: string | boolean
+    dropupAuto?: boolean
+    header?: string
+    hideDisabled?: boolean
+    iconBase?: string
+    liveSearch?: boolean
+    liveSearchNormalize?: boolean
+    liveSearchPlaceholder?: string
+    liveSearchStyle?: string
+    maxOptions?: number | boolean
+    maxOptionsText?: string | Array<any> | Function
+    mobile?: boolean
+    multipleSeparator?: string
+    noneSelectedText?: string
+    selectAllText?: string
+    selectedTextFormat?: string
+    selectOnTab?: boolean
+    showContent?: boolean
+    showIcon?: boolean
+    showSubtext?: boolean
+    showTick?: boolean
+    size?: string | number | boolean
+    style?: string
+    tickIcon?: string
+    title?: string
+    width?: string | boolean
+}
+
+interface JQuery {
+    selectpicker(opts?: BootstrapSelectOptions): void
+    selectpicker(method: string, ...args: Array<string | Array<string>>): void
+}

bootstrap-select/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "bootstrap-select-tests.ts"
+    ]
+}

chance/index.d.ts

@@ -5,13 +5,19 @@
 
 declare namespace Chance {
 
+    interface Seeded {
+        seed: number;
+    }
+
+    type SeededChance = Chance & Seeded;
+
     interface ChanceStatic {
         (): Chance
-        (seed: number): Chance
+        (seed: number): SeededChance
         (generator: () => any): Chance
 
         new(): Chance;
-        new(seed: number): Chance;
+        new(seed: number): SeededChance;
         new(generator: () => any): Chance;
     }
 

classnames/index.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Dave Keen <http://www.keendevelopment.ch>, Adi Dahiya <https://github.com/adidahiya>, Jason Killian <https://github.com/JKillian>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare type ClassValue = string | number | ClassDictionary | ClassArray | undefined | null;
+declare type ClassValue = string | number | ClassDictionary | ClassArray | undefined | null | false;
 
 interface ClassDictionary {
 	[id: string]: boolean | undefined | null;

color/color-tests.ts

@@ -0,0 +1,79 @@
+import * as Color from "color"
+
+var color: Color.Color = Color("white")
+var colorOther: Color.Color = Color("black")
+
+var colorRGB: Color.Color = color.rgb(0, 0, 0)
+var colorRGB: Color.Color = color.rgb([0, 0, 0])
+var rgb: Color.RGBColor = color.rgb()
+
+var colorHSL: Color.Color = color.hsl([0, 0, 0])
+var hsl: Color.HSLColor = color.hsl()
+
+var colorHSV: Color.Color = color.hsv([0, 0, 0])
+var hsv: Color.HSVColor = color.hsv()
+
+var colorHBW: Color.Color = color.hbw([0, 0, 0])
+var hbw: Color.HBWColor = color.hbw()
+
+var colorCMYK: Color.Color = color.cmyk([0, 0, 0, 0])
+var cmyk: Color.CMYKColor = color.cmyk()
+
+var hex: string = color.hexString()
+var percent: string = color.percentString()
+var keyword: string | void = color.keyword()
+var alpha: number = color.alpha()
+var red: number = color.red()
+var green: number = color.green()
+var blue: number = color.blue()
+var hue: number = color.hue()
+var saturation: number = color.saturation()
+var lightness: number = color.lightness()
+var saturationv: number = color.saturationv()
+var value: number = color.value()
+var whiteness: number = color.whiteness()
+var blackness: number = color.blackness()
+var cyan: number = color.cyan()
+var magenta: number = color.magenta()
+var yellow: number = color.yellow()
+var black: number = color.black()
+var luminosity: number = color.luminosity()
+var contrast: number = color.contrast(colorOther)
+var dark: boolean = color.dark()
+var light: boolean = color.light()
+var level: string = color.level(colorOther)
+
+var chain: Color.Color = color
+    .rgb(0, 0, 0)
+    .hsl([0, 0, 0])
+    .hsv([0, 0, 0])
+    .hbw([0, 0, 0])
+    .cmyk([0, 0, 0 ,0])
+    .alpha(0)
+    .red(0)
+    .green(0)
+    .blue(0)
+    .hue(0)
+    .saturation(0)
+    .lightness(0)
+    .saturationv(0)
+    .value(0)
+    .whiteness(0)
+    .blackness(0)
+    .cyan(0)
+    .magenta(0)
+    .yellow(0)
+    .black(0)
+    .negate()
+    .lighten(0)
+    .darken(0)
+    .saturate(0)
+    .desaturate(0)
+    .greyscale()
+    .whiten(0)
+    .blacken(0)
+    .clearer(0)
+    .opaquer(0)
+    .rotate(0)
+    .mix(colorOther, 0)
+    .clone()

color/index.d.ts

@@ -0,0 +1,161 @@
+// Type definitions for color v0.12.0
+// Project: https://github.com/qix-/color
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace Color {
+
+    interface RGBColor {
+        r: number
+        g: number
+        b: number
+        a?: number
+    }
+
+    interface FullRGBColor {
+        red: number
+        green: number
+        blue: number
+        alpha?: number
+    }
+
+    interface HSLColor {
+        h: number
+        s: number
+        l: number
+        a?: number
+    }
+
+    interface FullHSLColor {
+        hue: number
+        saturation: number
+        lightness: number
+        alpha?: number
+    }
+
+    interface HSVColor {
+        h: number
+        s: number
+        v: number
+    }
+
+    interface FullHSVColor {
+        hue: number
+        saturation: number
+        value: number
+    }
+
+    interface HBWColor {
+        h: number
+        b: number
+        w: number
+    }
+
+    interface FullHBWColor {
+        hue: number
+        whiteness: number
+        blackness: number
+    }
+
+    interface CMYKColor {
+        c: number
+        m: number
+        y: number
+        k: number
+    }
+
+    interface FullCMYKColor {
+        cyan: number
+        magenta: number
+        yellow: number
+        black: number
+    }
+
+    type ColorParam = string | RGBColor | FullRGBColor | HSLColor | FullHSLColor | HSVColor
+        | FullHSVColor | HBWColor | FullHBWColor | CMYKColor | FullCMYKColor
+
+    interface Color {
+        (color: ColorParam | Color) : Color
+        rgb(values: Array<number>): Color
+        rgb(r: number, g: number, b: number, a?: number): Color
+        rgb(values: RGBColor): Color
+        rgb(values: FullRGBColor): Color
+        rgb(): RGBColor
+        rgbArray(): Array<number>
+        rgbString(): string
+        rgbaString(): string
+        rgbNumber(): number
+        hsl(values: Array<number>): Color
+        hsl(): HSLColor
+        hslArray(): Array<number>
+        hslString(): string
+        hslaString(): string
+        hsv(values: Array<number>): Color
+        hsv(): HSVColor
+        hsvArray(): Array<number>
+        hsvString(): string
+        hbw(values: Array<number>): Color
+        hbw(): HBWColor
+        hbwArray(): Array<number>
+        hbwString(): string
+        cmyk(values: Array<number>): Color
+        cmyk(): CMYKColor
+        cmykArray(): Array<number>
+        cmykString(): string
+        hexString(): string
+        percentString(): string
+        keyword(): string | void
+        alpha(alpha: number): Color
+        alpha(): number
+        red(red: number): Color
+        red(): number
+        green(green: number): Color
+        green(): number
+        blue(blue: number): Color
+        blue(): number
+        hue(hue: number): Color
+        hue(): number
+        saturation(saturation: number): Color
+        saturation(): number
+        lightness(lightness: number): Color
+        lightness(): number
+        saturationv(saturationv: number): Color
+        saturationv(): number
+        value(value: number): Color
+        value(): number
+        whiteness(whiteness: number): Color
+        whiteness(): number
+        blackness(blackness: number): Color
+        blackness(): number
+        cyan(cyan: number): Color
+        cyan(): number
+        magenta(magenta: number): Color
+        magenta(): number
+        yellow(yellow: number): Color
+        yellow(): number
+        black(black: number): Color
+        black(): number
+        luminosity(): number
+        contrast(color: Color): number
+        dark(): boolean
+        light(): boolean
+        negate(): Color
+        lighten(value: number): Color
+        darken(value: number): Color
+        saturate(value: number): Color
+        desaturate(value: number): Color
+        greyscale(): Color
+        whiten(value: number): Color
+        blacken(value: number): Color
+        clearer(value: number): Color
+        opaquer(value: number): Color
+        rotate(value: number): Color
+        mix(color: Color, value?: number): Color
+        level(color: Color): string
+        clone(): Color
+    }
+}
+
+declare const Color: Color.Color;
+export = Color;
+export as namespace Color;

color/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "color-tests.ts"
+    ]
+}

cordova-plugin-ble-central/cordova-plugin-ble-central-tests.ts

@@ -0,0 +1,119 @@
+var log = (msg : string) => {};
+var devices: BLECentralPlugin.PeripheralData[] = [];
+var demoDevice :BLECentralPlugin.PeripheralData = {
+    "name": "Battery Demo",
+    "id": "20:FF:D0:FF:D1:C0",
+    "advertising": [2,1,6,3,3,15,24,8,9,66,97,116,116,101,114,121],
+    "rssi": -55
+};
+
+devices.push(demoDevice);
+var demoExtendedData : BLECentralPlugin.PeripheralDataExtended = {
+    "name": "Battery Demo",
+    "id": "20:FF:D0:FF:D1:C0",
+    "advertising": [2,1,6,3,3,15,24,8,9,66,97,116,116,101,114,121],
+    "rssi": -55,
+    "services": [
+        "1800",
+        "1801",
+        "180f"
+    ],
+    "characteristics": [
+        {
+            "service": "1800",
+            "characteristic": "2a00",
+            "properties": [
+                "Read"
+            ]
+        },
+        {
+            "service": "1800",
+            "characteristic": "2a01",
+            "properties": [
+                "Read"
+            ]
+        },
+        {
+            "service": "1801",
+            "characteristic": "2a05",
+            "properties": [
+                "Read"
+            ]
+        },
+        {
+            "service": "180f",
+            "characteristic": "2a19",
+            "properties": [
+                "Read"
+            ],
+            "descriptors": [
+                {
+                    "uuid": "2901"
+                },
+                {
+                    "uuid": "2904"
+                }
+            ]
+        }
+    ]
+};
+
+
+//get updates about the bluethooth states
+ble.startStateNotifications((state) => log(`BLE state ${state}`));
+
+ble.isEnabled(()=> log(`bluetooth is enabled`), ()=>log(`bluetooth is not enabled`));
+
+//here we try to enable bluetooth
+ble.enable(() => log(`yes it worked, or it was already enabled `), () => log(`nope it didn't work, the user pressed cancel, or we are in iOS`));
+
+ble.showBluetoothSettings(() => log(`yes it worked`), () => log(`nope it didn't work`))
+
+//stop getting updates about the bluethooth states
+ble.stopStateNotifications()
+
+//scan 5 seconds
+ble.scan([], 5000, (data) => { devices.push(data); }, ()=> log('couldn\'t connect') );
+
+//scan continously
+ble.startScan([], (data) => { devices.push(data); }, ()=> log('couldn\'t connect')  )
+
+////scan continously
+ble.startScanWithOptions([], {reportDuplicates:false }, (data) => { devices.push(data); }, ()=> log('couldn\'t connect')  )
+
+//stop scanning
+ble.stopScan(()=> log('all good'), ()=> log('couldn\'t stop scanning'));
+
+//are we conenected to that device?
+ble.isConnected(demoDevice.id, () => log(`already connected to this device`), ()=> log(`not yet connected to that device`));
+
+//connect to a specific device
+var extendedData : BLECentralPlugin.PeripheralDataExtended;
+ble.connect(demoDevice.id, (data)=> extendedData = data, () => log(`couldn't connect to the device`) );
+
+//read some data from a characteristic
+var charsOfOneOfItsServices = demoExtendedData.characteristics.filter((value) => value.service == demoExtendedData.services[0]);
+ble.read(demoDevice.id, charsOfOneOfItsServices[0].service,  charsOfOneOfItsServices[0].characteristic, (data) => log(`we've received some data`), ()=> log(`couldn't read any data`));
+
+//read the rssi
+ble.readRSSI(demoDevice.id, (rssi)=>log(`Device ${demoDevice.name} has an RSSI of ${rssi}`));
+
+var notificationsReceived : number = 0;
+//get notified of changes for that characteristic
+ble.startNotification(demoDevice.id, charsOfOneOfItsServices[0].service, charsOfOneOfItsServices[0].characteristic, (data)=> notificationsReceived++, ()=> log(`darn`));
+
+//write some data
+ble.write(demoDevice.id, charsOfOneOfItsServices[0].service, charsOfOneOfItsServices[0].characteristic, new ArrayBuffer(40), ()=> log(`all good`), ()=> log(`could't write`));
+//write some data without getting notified
+ble.writeWithoutResponse(demoDevice.id, charsOfOneOfItsServices[0].service, charsOfOneOfItsServices[0].characteristic, new ArrayBuffer(40), ()=> log(`all good`), ()=> log(`could't write`));
+
+//stop getting notified of changes.
+ble.stopNotification(demoDevice.id, charsOfOneOfItsServices[0].service, charsOfOneOfItsServices[0].characteristic);
+
+//notificationsReceived == 1
+
+//just disconnect
+ble.disconnect(demoDevice.id);
+
+
+

cordova-plugin-ble-central/index.d.ts

@@ -0,0 +1,108 @@
+// Type definitions for cordova-plugin-ble-central 1.1.2
+// Project: https://github.com/don/cordova-plugin-ble-central
+// Definitions by: Gidon Junge <https://github.com/gjunge>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+declare namespace BLECentralPlugin {
+
+  interface PeripheralCharacteristic {
+        service: string;
+        characteristic: string;
+        properties: string[];
+        descriptors?: any[];
+    }
+
+    interface PeripheralData {
+        name: string;
+        id: string;
+        rssi: number
+        advertising: ArrayBuffer|any;
+    }
+
+
+    interface PeripheralDataExtended  extends PeripheralData{
+            services: string[];
+            characteristics: PeripheralCharacteristic[]
+    }
+
+  
+
+
+    interface StartScanOptions {
+        reportDuplicates?: boolean;
+    }
+
+    export interface BLECentralPluginStatic {
+        scan(services: string[], seconds: number, success : (data: PeripheralData) => any): void;
+        scan(services: string[], seconds: number, success : (data: PeripheralData) => any, failure : () => any): void;
+        
+        startScan(services: string[], success: (data: PeripheralData) => any): void;
+        startScan(services: string[], success: (data: PeripheralData) => any, failure: () => any): void;
+
+        startScanWithOptions(services: string[], options: StartScanOptions, success: (data: PeripheralData) => any): void;
+        startScanWithOptions(services: string[], options: StartScanOptions, success: (data: PeripheralData) => any, failure: () => any): void;
+
+        stopScan(): void;
+        stopScan(success: () => any): void;
+        stopScan(success: () => any, failure: () => any): void;
+        
+        connect(device_id:string, success: (data: PeripheralDataExtended) => any, failure: () => any): void;
+
+        disconnect(device_id:string): void;
+        disconnect(device_id:string, success: () => any): void;
+        disconnect(device_id:string, success: () => any, failure: () => any): void;
+
+        read(device_id: string, service_uuid:string, characteristic_uuid:string): void;
+        read(device_id: string, service_uuid:string, characteristic_uuid:string, success: (rawData: ArrayBuffer) => any): void;
+        read(device_id: string, service_uuid:string, characteristic_uuid:string, success: (rawData: ArrayBuffer) => any, failure: () => any): void;
+
+        write(device_id: string, service_uuid:string, characteristic_uuid:string, data: ArrayBuffer): void;
+        write(device_id: string, service_uuid:string, characteristic_uuid:string, data: ArrayBuffer, success  : () => any): void;
+        write(device_id: string, service_uuid:string, characteristic_uuid:string, data: ArrayBuffer, success  : () => any, failure: () => any): void;
+
+        /* Writes data to a characteristic without a response from the peripheral. You are not notified if the write fails in the BLE stack. 
+        The success callback is be called when the characteristic is written.*/
+        writeWithoutResponse(device_id: string, service_uuid:string, characteristic_uuid:string, data: ArrayBuffer): void;
+        writeWithoutResponse(device_id: string, service_uuid:string, characteristic_uuid:string, data: ArrayBuffer, success : () => any): void;
+        writeWithoutResponse(device_id: string, service_uuid:string, characteristic_uuid:string, data: ArrayBuffer, success : () => any, failure: () => any): void;
+
+        /* Register to be notified when the value of a characteristic changes. */
+        startNotification(device_id: string, service_uuid:string, characteristic_uuid:string, success: (rawData: ArrayBuffer) => any): void;
+        startNotification(device_id: string, service_uuid:string, characteristic_uuid:string, success: (rawData: ArrayBuffer) => any, failure: () => any): void;
+        
+        stopNotification(device_id: string, service_uuid:string, characteristic_uuid:string): void;
+        stopNotification(device_id: string, service_uuid:string, characteristic_uuid:string, success: () => any): void;
+        stopNotification(device_id: string, service_uuid:string, characteristic_uuid:string, success: () => any, failure: () => any): void;
+
+        /* Reports if bluetooth is enabled. */
+        isEnabled(success: () => any , failure: () => any): void;
+
+        /* Calls the success callback when the peripheral is connected and the failure callback when not connected. */
+        isConnected(device_id: string, success: () => any): void;
+        isConnected(device_id: string, success: () => any, failure: () => any): void;
+
+        startStateNotifications(success: (state: string) => any): void;
+        startStateNotifications(success: (state: string) => any, failure: () => any): void;
+
+        stopStateNotifications(): void;
+        stopStateNotifications(success: () => any): void;
+        stopStateNotifications(success: () => any, failure: () => any): void;
+        
+        /* Opens the Bluetooth settings for the operating systems.
+           [iOS] showBluetoothSettings is not supported on iOS. */
+        showBluetoothSettings(): void;
+        showBluetoothSettings(success: () => any): void;
+        showBluetoothSettings(success: () => any, failure: () => any): void;
+        
+        /* Enable Bluetooth on the device.
+           [iOS] enable is not supported on iOS. */
+        enable(success: () => any, failure: () => any): void;
+        
+
+        readRSSI(device_id:string, success: (rssi: number) => any): void;
+        readRSSI(device_id:string, success: (rssi: number) => any, failure: () => any): void;
+    }
+}
+
+declare var ble: BLECentralPlugin.BLECentralPluginStatic;

cordova-plugin-ble-central/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "cordova-plugin-ble-central-tests.ts"
+    ]
+}

cordova.plugins.diagnostic/cordova.plugins.diagnostic-tests.ts

@@ -0,0 +1,532 @@
+/// <reference types="cordova-plugin-device" />
+
+cordova.plugins.diagnostic.isLocationAvailable(function(available){
+    console.log("Location is " + (available ? "available" : "not available"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isWifiAvailable(function(available){
+    console.log("WiFi is " + (available ? "available" : "not available"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isCameraAvailable(function(available){
+    console.log("Camera is " + (available ? "available" : "not available"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isBluetoothAvailable(function(available){
+    console.log("Bluetooth is " + (available ? "available" : "not available"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.switchToLocationSettings();
+cordova.plugins.diagnostic.switchToMobileDataSettings();
+cordova.plugins.diagnostic.switchToBluetoothSettings();
+cordova.plugins.diagnostic.switchToWifiSettings();
+
+cordova.plugins.diagnostic.isWifiEnabled(function(enabled){
+    console.log("WiFi is " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.setWifiState(function(){
+        console.log("Wifi was enabled");
+    }, function(error){
+        console.error("The following error occurred: "+error);
+    }, true
+);
+
+cordova.plugins.diagnostic.setBluetoothState(function(){
+        console.log("Bluetooth was enabled");
+    }, function(error){
+        console.error("The following error occurred: "+error);
+    }, true
+);
+
+cordova.plugins.diagnostic.isLocationEnabled(function(enabled){
+    console.log("Location setting is " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isLocationAuthorized(function(enabled){
+    console.log("Location authorization is " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getLocationAuthorizationStatus(function(status){
+    switch(status){
+        case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+            console.log("Permission not requested");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED:
+            console.log("Permission denied");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+            console.log("Permission granted always");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED_WHEN_IN_USE:
+            console.log("Permission granted only when in use");
+            break;
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestLocationAuthorization(function(status){
+    switch(status){
+        case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+            console.log("Permission not requested");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED:
+            console.log("Permission denied");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+            console.log("Permission granted always");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED_WHEN_IN_USE:
+            console.log("Permission granted only when in use");
+            break;
+    }
+}, function(error){
+    console.error(error);
+}, cordova.plugins.diagnostic.locationAuthorizationMode.ALWAYS);
+
+cordova.plugins.diagnostic.isCameraPresent(function(present){
+    console.log("Camera is " + (present ? "present" : "absent"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isCameraAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "denied") + " access to the camera");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getCameraAuthorizationStatus(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Camera use is authorized");
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestCameraAuthorization(function(status){
+    console.log("Authorization request for camera use was " + (status == cordova.plugins.diagnostic.permissionStatus.GRANTED ? "granted" : "denied"));
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.isMicrophoneAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "denied") + " access to the microphone");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getMicrophoneAuthorizationStatus(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Microphone use is authorized");
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestMicrophoneAuthorization(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Microphone use is authorized");
+    }
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.isContactsAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "denied") + " access to contacts");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getContactsAuthorizationStatus(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Contacts use is authorized");
+    }
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.requestContactsAuthorization(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Contacts use is authorized");
+    }
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.isCalendarAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "denied") + " access to calendar");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getCalendarAuthorizationStatus(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Calendar use is authorized");
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestCalendarAuthorization(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Calendar use is authorized");
+    }
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.switchToSettings(function(){
+    console.log("Successfully switched to Settings app");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getBluetoothState(function(state){
+    if(state === cordova.plugins.diagnostic.bluetoothState.POWERED_ON){
+        console.log("Bluetooth is able to connect");
+    }
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.registerBluetoothStateChangeHandler(function(state){
+    if(state === cordova.plugins.diagnostic.bluetoothState.POWERED_ON){
+        console.log("Bluetooth is able to connect");
+    }
+});
+
+cordova.plugins.diagnostic.registerLocationStateChangeHandler(function(state){
+    if((device.platform === "Android" && state !== cordova.plugins.diagnostic.locationMode.LOCATION_OFF)
+        || (device.platform === "iOS") && ( state === cordova.plugins.diagnostic.permissionStatus.GRANTED
+            || state === cordova.plugins.diagnostic.permissionStatus.GRANTED_WHEN_IN_USE
+        )){
+        console.log("Location is available");
+    }
+});
+
+cordova.plugins.diagnostic.getLocationMode(function(locationMode){
+    switch(locationMode){
+        case cordova.plugins.diagnostic.locationMode.HIGH_ACCURACY:
+            console.log("High accuracy");
+            break;
+        case cordova.plugins.diagnostic.locationMode.BATTERY_SAVING:
+            console.log("Battery saving");
+            break;
+        case cordova.plugins.diagnostic.locationMode.DEVICE_ONLY:
+            console.log("Device only");
+            break;
+        case cordova.plugins.diagnostic.locationMode.LOCATION_OFF:
+            console.log("Location off");
+            break;
+    }
+},function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isGpsLocationAvailable(function(available){
+    console.log("GPS location is " + (available ? "available" : "not available"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isGpsLocationEnabled(function(enabled){
+    console.log("GPS location is " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isNetworkLocationAvailable(function(available){
+    console.log("Network location is " + (available ? "available" : "not available"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isNetworkLocationEnabled(function(enabled){
+    console.log("Network location is " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getLocationMode(function(locationMode){
+    switch(locationMode){
+        case cordova.plugins.diagnostic.locationMode.HIGH_ACCURACY:
+            console.log("High accuracy");
+            break;
+        case cordova.plugins.diagnostic.locationMode.BATTERY_SAVING:
+            console.log("Battery saving");
+            break;
+        case cordova.plugins.diagnostic.locationMode.DEVICE_ONLY:
+            console.log("Device only");
+            break;
+        case cordova.plugins.diagnostic.locationMode.LOCATION_OFF:
+            console.log("Location off");
+            break;
+    }
+},function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getPermissionAuthorizationStatus(function(status){
+    switch(status){
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+            console.log("Permission granted to use the camera");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+            console.log("Permission to use the camera has not been requested yet");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED:
+            console.log("Permission denied to use the camera - ask again?");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
+            console.log("Permission permanently denied to use the camera - guess we won't be using it then!");
+            break;
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+}, cordova.plugins.diagnostic.permission.CAMERA);
+
+cordova.plugins.diagnostic.getPermissionsAuthorizationStatus(function(statuses){
+    for (var permission in statuses){
+        switch(statuses[permission]){
+            case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+                console.log("Permission granted to use "+permission);
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+                console.log("Permission to use "+permission+" has not been requested yet");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED:
+                console.log("Permission denied to use "+permission+" - ask again?");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
+                console.log("Permission permanently denied to use "+permission+" - guess we won't be using it then!");
+                break;
+        }
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+},[
+    cordova.plugins.diagnostic.permission.ACCESS_FINE_LOCATION,
+    cordova.plugins.diagnostic.permission.ACCESS_COARSE_LOCATION
+]);
+
+cordova.plugins.diagnostic.requestRuntimePermission(function(status){
+    switch(status){
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+            console.log("Permission granted to use the camera");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+            console.log("Permission to use the camera has not been requested yet");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED:
+            console.log("Permission denied to use the camera - ask again?");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
+            console.log("Permission permanently denied to use the camera - guess we won't be using it then!");
+            break;
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+}, cordova.plugins.diagnostic.permission.CAMERA);
+
+cordova.plugins.diagnostic.requestRuntimePermissions(function(statuses){
+    for (var permission in statuses){
+        switch(statuses[permission]){
+            case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+                console.log("Permission granted to use "+permission);
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+                console.log("Permission to use "+permission+" has not been requested yet");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED:
+                console.log("Permission denied to use "+permission+" - ask again?");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
+                console.log("Permission permanently denied to use "+permission+" - guess we won't be using it then!");
+                break;
+        }
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+},[
+    cordova.plugins.diagnostic.permission.ACCESS_FINE_LOCATION,
+    cordova.plugins.diagnostic.permission.ACCESS_COARSE_LOCATION
+]);
+
+if(!cordova.plugins.diagnostic.isRequestingPermission()){
+    console.log("Request some permissions");
+}else{
+    cordova.plugins.diagnostic.registerPermissionRequestCompleteHandler(function(statuses){
+        cordova.plugins.diagnostic.registerPermissionRequestCompleteHandler(null); // de-register handler after single call
+        console.log("Request some permissions");
+    });
+}
+
+function onPermissionRequestComplete(statuses:any){
+    console.info("Permission request complete");
+    for (var permission in statuses){
+        switch(statuses[permission]){
+            case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+                console.log("Permission granted to use "+permission);
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+                console.log("Permission to use "+permission+" has not been requested yet");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED:
+                console.log("Permission denied to use "+permission);
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
+                console.log("Permission permanently denied to use "+permission);
+                break;
+        }
+    }
+    cordova.plugins.diagnostic.registerPermissionRequestCompleteHandler(null); // de-register handler
+}
+cordova.plugins.diagnostic.registerPermissionRequestCompleteHandler(onPermissionRequestComplete)
+
+cordova.plugins.diagnostic.isBluetoothEnabled(function(enabled){
+    console.log("Bluetooth is " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.hasBluetoothSupport(function(supported){
+    console.log("Bluetooth is " + (supported ? "supported" : "unsupported"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.hasBluetoothLESupport(function(supported){
+    console.log("Bluetooth LE is " + (supported ? "supported" : "unsupported"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.hasBluetoothLEPeripheralSupport(function(supported){
+    console.log("Bluetooth LE Peripheral Mode is " + (supported ? "supported" : "unsupported"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isCameraRollAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "denied") + " access to the camera roll");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getCameraRollAuthorizationStatus(function(status){
+    switch(status){
+        case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+            console.log("Permission not requested");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.DENIED:
+            console.log("Permission denied");
+            break;
+        case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+            console.log("Permission granted");
+            break;
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestCameraRollAuthorization(function(status){
+    console.log("Authorization request for camera roll was " + (status == cordova.plugins.diagnostic.permissionStatus.GRANTED ? "granted" : "denied"));
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.isRemoteNotificationsEnabled(function(enabled){
+    console.log("Remote notifications are " + (enabled ? "enabled" : "disabled"));
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isRegisteredForRemoteNotifications(function(registered){
+    console.log("Device " + (registered ? "is" : "isn't") + " registered for remote notifications");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getRemoteNotificationTypes(function(types){
+    for(var type in types){
+        console.log(type + " is " + (types[type] ? "enabled" : "disabled"));
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isRemindersAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "denied") + " access to reminders");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getRemindersAuthorizationStatus(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Reminders authorization allowed");
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestRemindersAuthorization(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Reminders authorization allowed");
+    }
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.isBackgroundRefreshAuthorized(function(authorized){
+    console.log("App is " + (authorized ? "authorized" : "not authorized") + " to perform background refresh");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.getBackgroundRefreshStatus(function(status){
+    if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+        console.log("Background refresh is allowed");
+    }
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestBluetoothAuthorization(function(){
+    console.log("Bluetooth authorization requested");
+}, function(error){
+    console.error(error);
+});
+
+cordova.plugins.diagnostic.isMotionAvailable(function(available){
+    console.log("Motion tracking is " + (available ? "available" : "not available") + " on this device");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.isMotionRequestOutcomeAvailable(function(available){
+    console.log("Motion tracking request outcome is " + (available ? "available" : "not available") + " on this device");
+}, function(error){
+    console.error("The following error occurred: "+error);
+});
+
+cordova.plugins.diagnostic.requestAndCheckMotionAuthorization(function(status){
+    console.log("Motion authorization is " +status);
+}, function(error){
+    console.error(error);
+});

cordova.plugins.diagnostic/index.d.ts

@@ -0,0 +1,738 @@
+// Type definitions for cordova.plugins.diagnostic v3.3.0
+// Project: https://github.com/dpa99c/cordova-diagnostic-plugin
+// Definitions by: Dave Alden <https://github.com/dpa99c/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="cordova" />
+
+/**
+ * Checks whether device hardware features are enabled or available to the app, e.g. camera, GPS, wifi
+ */
+interface Diagnostic {
+
+    /**
+     * ANDROID ONLY
+     * "Dangerous" permissions that need to be requested at run-time (Android 6.0/API 23 and above)
+     * See http://developer.android.com/guide/topics/security/permissions.html#perm-groups
+     * @type {Object}
+     */
+    permission?: any;
+
+    /**
+     * ANDROID ONLY
+     * Permission groups indicate which associated permissions will also be requested if a given permission is requested.
+     * See http://developer.android.com/guide/topics/security/permissions.html#perm-groups
+     * @type {Object}
+     */
+    permissionGroups?: any;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Constants for requesting and reporting the various permission states.
+     * @type {Object}
+     */
+    permissionStatus?: any;
+
+    /**
+     * iOS ONLY
+     * Location authorization mode
+     * @type {Object}
+     */
+    locationAuthorizationMode?: any;
+
+
+    /**
+     * ANDROID ONLY
+     * Constants for the various location modes on Android.
+     * @type {Object}
+     */
+    locationMode?: any;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Constants for the various Bluetooth hardware states.
+     * @type {Object}
+     */
+    bluetoothState?: any;
+
+
+    /**
+     * Checks if app is able to access device location.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isLocationAvailable: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * Checks if Wifi is available.
+     * On iOS this returns true if the device is connected to a network by WiFi.
+     * On Android and Windows 10 Mobile this returns true if the WiFi setting is set to enabled, and is the same as isWifiEnabled()
+     * @param successCallback
+     * @param errorCallback
+     */
+    isWifiAvailable: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * Checks if camera is available.
+     * On Android & iOS this returns true if the device has a camera AND the application is authorized to use it.
+     * On Windows 10 Mobile this returns true if the device has a rear-facing camera.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isCameraAvailable: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * Checks if Bluetooth is available to the app.
+     * Returns true if the device has Bluetooth capabilities AND if Bluetooth setting is switched on (same on Android, iOS and Windows 10 Mobile)
+     * @param successCallback
+     * @param errorCallback
+     */
+    isBluetoothAvailable: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Displays the device location settings to allow user to enable location services/change location mode.
+     */
+    switchToLocationSettings?: () => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Displays mobile settings to allow user to enable mobile data.
+     */
+    switchToMobileDataSettings?: () => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Displays Bluetooth settings to allow user to enable Bluetooth.
+     */
+    switchToBluetoothSettings?: () => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Displays WiFi settings to allow user to enable WiFi.
+     */
+    switchToWifiSettings?: () => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Returns true if the WiFi setting is set to enabled, and is the same as isWifiAvailable()
+     * @param successCallback
+     * @param errorCallback
+     */
+    isWifiEnabled?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Enables/disables WiFi on the device.
+     * @param successCallback
+     * @param errorCallback
+     * @param state
+     */
+    setWifiState?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void,
+        state: boolean
+    ) => void;
+
+    /**
+     * ANDROID and WINDOWS ONLY
+     * Enables/disables Bluetooth on the device.
+     * @param successCallback
+     * @param errorCallback
+     * @param state
+     */
+    setBluetoothState?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void,
+        state: boolean
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns true if the device setting for location is on.
+     * On Android this returns true if Location Mode is switched on.
+     * On iOS this returns true if Location Services is switched on.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isLocationEnabled?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Checks if the application is authorized to use location.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isLocationAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns the location authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getLocationAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Requests location authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     * @param mode - (iOS-only / optional) location authorization mode specified as a locationAuthorizationMode constant. If not specified, defaults to WHEN_IN_USE.
+     */
+    requestLocationAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void,
+        mode?: string
+    ) => void;
+
+
+    /**
+     * ANDROID and iOS ONLY
+     * Checks if camera hardware is present on device.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isCameraPresent?: (
+        successCallback: (present: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Checks if the application is authorized to use the camera.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isCameraAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns the camera authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getCameraAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Requests camera authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestCameraAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Checks if the application is authorized to use the microphone.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isMicrophoneAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns the microphone authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getMicrophoneAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Requests microphone authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestMicrophoneAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Checks if the application is authorized to use contacts (address book).
+     * @param successCallback
+     * @param errorCallback
+     */
+    isContactsAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns the contacts authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getContactsAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Requests contacts authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestContactsAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Checks if the application is authorized to use the calendar.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isCalendarAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns the calendar authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getCalendarAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Requests calendar authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestCalendarAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Opens settings page for this app.
+     * On Android, this opens the "App Info" page in the Settings app.
+     * On iOS, this opens the app settings page in the Settings app. This works only on iOS 8+ - iOS 7 and below will invoke the errorCallback.
+     */
+    switchToSettings?: (
+        successCallback: () => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Returns the state of Bluetooth on the device.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getBluetoothState?: (
+        successCallback: (state: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Registers a function to be called when a change in Bluetooth state occurs. Pass in a falsey value to de-register the currently registered function.
+     * @param successCallback
+     */
+    registerBluetoothStateChangeHandler?: (
+        successCallback: (state: string) => void
+    ) => void;
+
+    /**
+     * ANDROID and iOS ONLY
+     * Registers a function to be called when a change in Location state occurs. Pass in a falsey value to de-register the currently registered function.
+     * On Android, this occurs when the Location Mode is changed.
+     * On iOS, this occurs when location authorization status is changed. This can be triggered either by the user's response to a location permission authorization dialog, by the user turning on/off Location Services, or by the user changing the Location authorization state specifically for your app.
+     * @param successCallback
+     */
+    registerLocationStateChangeHandler?: (
+        successCallback: (state: string) => void
+    ) => void;
+
+
+    /**
+     * ANDROID ONLY
+     * Checks if high-accuracy locations are available to the app from GPS hardware.
+     * Returns true if Location mode is enabled and is set to "Device only" or "High accuracy" AND if the app is authorised to use location.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isGpsLocationAvailable?: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if the device location setting is set to return high-accuracy locations from GPS hardware.
+     * Returns true if Location mode is enabled and is set to either Device only or High accuracy
+     * @param successCallback
+     * @param errorCallback
+     */
+    isGpsLocationEnabled?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if low-accuracy locations are available to the app from network triangulation/WiFi access points.
+     * Returns true if Location mode is enabled and is set to "Battery saving" or "High accuracy" AND if the app is authorised to use location.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isNetworkLocationAvailable?: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if the device location setting is set to return high-accuracy locations from GPS hardware.
+     * Returns true if Location mode is enabled and is set to either Battery saving or High accuracy
+     * @param successCallback
+     * @param errorCallback
+     */
+    isNetworkLocationEnabled?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Returns the current location mode setting for the device.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getLocationMode?: (
+        successCallback: (mode: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Returns the current authorisation status for a given permission.
+     * @param successCallback
+     * @param errorCallback
+     * @param permission
+     */
+    getPermissionAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void,
+        permission: string
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Returns the current authorisation status for multiple permissions.
+     * @param successCallback
+     * @param errorCallback
+     * @param permissions
+     */
+    getPermissionsAuthorizationStatus?: (
+        successCallback: (status: string[]) => void,
+        errorCallback: (error: string) => void,
+        permissions: string[]
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Requests app to be granted authorisation for a runtime permission.
+     * @param successCallback
+     * @param errorCallback
+     * @param permission
+     */
+    requestRuntimePermission?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void,
+        permission: string
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Requests app to be granted authorisation for multiple runtime permissions.
+     * @param successCallback
+     * @param errorCallback
+     * @param permissions
+     */
+    requestRuntimePermissions?: (
+        successCallback: (status: string[]) => void,
+        errorCallback: (error: string) => void,
+        permissions: string[]
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Indicates if the plugin is currently requesting a runtime permission via the native API.
+     */
+    isRequestingPermission?: () => boolean;
+
+    /**
+     * ANDROID ONLY
+     * Registers a function to be called when a runtime permission request has completed. Pass in a falsey value to de-register the currently registered function.
+     * @param successCallback
+     */
+    registerPermissionRequestCompleteHandler?: (
+        successCallback: (statuses: any) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if the device setting for Bluetooth is switched on.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isBluetoothEnabled?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if the device has Bluetooth capabilities.
+     * @param successCallback
+     * @param errorCallback
+     */
+    hasBluetoothSupport?: (
+        successCallback: (supported: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if the device has Bluetooth Low Energy (LE) capabilities.
+     * @param successCallback
+     * @param errorCallback
+     */
+    hasBluetoothLESupport?: (
+        successCallback: (supported: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     * Checks if the device supports Bluetooth Low Energy (LE) Peripheral mode.
+     * @param successCallback
+     * @param errorCallback
+     */
+    hasBluetoothLEPeripheralSupport?: (
+        successCallback: (supported: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if the application is authorized to use the Camera Roll in Photos app.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isCameraRollAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Returns the authorization status for the application to use the Camera Roll in Photos app.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getCameraRollAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Requests camera roll authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestCameraRollAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if remote (push) notifications are enabled.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isRemoteNotificationsEnabled?: (
+        successCallback: (enabled: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Indicates if the app is registered for remote (push) notifications on the device.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isRegisteredForRemoteNotifications?: (
+        successCallback: (registered: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Indicates the current setting of notification types for the app in the Settings app.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getRemoteNotificationTypes?: (
+        successCallback: (types: any) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if the application is authorized to use reminders.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isRemindersAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Returns the reminders authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getRemindersAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Requests reminders authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestRemindersAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if the application is authorized for background refresh.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isBackgroundRefreshAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Returns the background refresh authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getBackgroundRefreshStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Requests Bluetooth authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestBluetoothAuthorization?: (
+        successCallback: () => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if motion tracking is available on the current device.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isMotionAvailable?: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if it's possible to determine the outcome of a motion authorization request on the current device.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isMotionRequestOutcomeAvailable?: (
+        successCallback: (available: boolean) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Requests and checks motion authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestAndCheckMotionAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+}
+
+interface CordovaPlugins {
+    diagnostic: Diagnostic
+}

cordova.plugins.diagnostic/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "cordova.plugins.diagnostic-tests.ts"
+    ]
+}

credit-card-type/credit-card-type-tests.ts

@@ -0,0 +1,5 @@
+import * as creditCardType from "credit-card-type"
+
+var cardTypes: Array<creditCardType.CreditCardTypeInfo> = creditCardType("")
+var cardInfo: creditCardType.CreditCardTypeInfo = creditCardType.getTypeInfo("")
+var types: { [type: string]: string } = creditCardType.types

credit-card-type/index.d.ts

@@ -0,0 +1,30 @@
+// Type definitions for Credit Card Type v5.0.0
+// Project: https://github.com/braintree/credit-card-type
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace creditCardType {
+
+    type CardBrand = "american-express" | "diners-club" | "discover" | "jcb" | "maestro" | "master-card" | "unionpay" | "visa"
+
+    interface CreditCardTypeInfo {
+        niceType?: string
+        type?: CardBrand
+        pattern?: RegExp
+        gaps?: Array<number>
+        lengths?: Array<number>
+        code?: {
+            name?: string
+            size?: number
+        }
+    }
+
+    interface CreditCardType {
+        (number: string): Array<CreditCardTypeInfo>
+        getTypeInfo (type: string): CreditCardTypeInfo
+        types: { [type: string]: string }
+    }
+}
+
+declare const creditCardType: creditCardType.CreditCardType
+export = creditCardType

credit-card-type/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "credit-card-type-tests.ts"
+    ]
+}

electron/electron-prebuilt.d.ts

@@ -1,8 +0,0 @@
-// Type definitions for electron 1.3.3
-// Project: https://github.com/electron-userland/electron-prebuilt
-// Definitions by: rhysd <https://github.com/rhysd>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-/// <reference path="../electron/electron.d.ts" />
-
-// this file will be removed.

enzyme/enzyme-tests.tsx

@@ -201,7 +201,7 @@ namespace ShallowWrapperTest {
     }
 
     function test_state() {
-        shallowWrapper.state();
+        const state: MyComponentState = shallowWrapper.state();
         shallowWrapper.state('key');
         const tmp: String = shallowWrapper.state<String>('key');
     }

enzyme/index.d.ts

@@ -202,8 +202,9 @@ interface CommonWrapper<P, S> {
      * Returns the state hash for the root node of the wrapper. Optionally pass in a prop name and it will return just that value.
      * @param [key]
      */
-    state(key?: string): any;
-    state<T>(key?: string): T;
+    state(): S;
+    state(key: string): any;
+    state<T>(key: string): T;
 
     /**
      * Returns the context hash for the root node of the wrapper. Optionally pass in a prop name and it will return just that value.

es6-error/es6-error-tests.ts

@@ -0,0 +1,9 @@
+import * as ExtendableError from "es6-error"
+
+class TestError extends ExtendableError {
+    constructor (message: string = "TestError") {
+        super(message)
+    }
+}
+
+throw new TestError("Test Message")

es6-error/index.d.ts

@@ -0,0 +1,6 @@
+// Type definitions for es6-error v4.0.0
+// Project: https://github.com/bjyoungblood/es6-error
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = Error;

es6-error/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "es6-error-tests.ts"
+    ]
+}

event-kit/event-kit-tests.ts

@@ -24,6 +24,7 @@ class User {
 	}
 
 	destroy(): void {
+		this.emitter.clear();
 		this.emitter.dispose();
 	}
 }
@@ -39,6 +40,7 @@ var user = new User();
 var subscription = user.onDidChangeName((name: string) => {
 	console.log('User name change to: ' + name);
 });
+if(Disposable.isDisposable(subscription)) {}
 subscription.dispose();
 
 // CompositeDisposable

event-kit/index.d.ts

@@ -14,6 +14,10 @@ declare namespace AtomEventKit {
 	interface DisposableStatic {
 		prototype: Disposable;
 		new (disposalAction: Function): Disposable;
+		/**
+		* Ensure that Object correctly implements the Disposable.
+		*/
+		isDisposable(object: Object): boolean;
 	}
 
 	/** Instance side of the Disposable class. */
@@ -59,6 +63,13 @@ declare namespace AtomEventKit {
 		isDisposed: boolean;
 
 		constructor: EmitterStatic;
+		/**
+		* Clear out any existing subscribers.
+		*/
+		clear(): void;
+		/**
+		* Unsubscribe all handlers.
+		*/
 		dispose(): void;
 		/**
 		* Registers a handler to be invoked whenever the given event is emitted.

eventemitter3/eventemitter3-tests.ts

@@ -1,585 +1,116 @@
-///<reference types="node" />
-///<reference types="mocha" />
 'use strict';
 
-import EventEmitter = require('eventemitter3');
-import util = require('util');
-import * as EventEmitter3ImportedAsES6Module from 'eventemitter3';
+import * as EventEmitter from 'eventemitter3';
 
-declare namespace Assume {
-  interface Class<T> {
-    new(...args: any[]): T;
-  }
-
-  interface Assume<T> {
-    equals(compare: T): Assume<T>;
-    equal(compare: T): Assume<T>;
-    eqls(compare: T): Assume<T>;
-    is: Assume<T>;
-    deep: Assume<T>;
-    to: Assume<T>;
-    either(arr: T[]): Assume<T>;
-    instanceOf(clazz: Class<T>): Assume<T>;
-    a(typeofString: string): Assume<T>;
-  }
-
-  export function assume<T>(input: T): Assume<T>;
-}
-
-let assume = Assume.assume;
-
-class EventEmitterTest {
-    v: any;
+const eventName = 'test';
+const eventSymbol: symbol = Symbol('test');
+const fn = () => console.log(1);
 
+// Extending EventEmitter
+class TestEmitter extends EventEmitter {
     constructor() {
-        this.v = new EventEmitter();
-        this.v = new EventEmitter3ImportedAsES6Module();
-
-        // Some methods are missing or incompatible with current implementation (v4.2.x) of NodeJS.EventEmitter
-        // (e.g. getMaxListenters or listeners)
-        // var n: NodeJS.EventEmitter = this.v;
+        super();
     }
 
-    listeners() {
-        var v1: Function[] = this.v.listeners('click');
-    }
-
-    emit() {
-        var v1: boolean = this.v.emit('click');
-        var v2: boolean = this.v.emit('click', 1);
-        var v3: boolean = this.v.emit('click', 1, '1');
-        var v4: boolean = this.v.emit('click', 1, '1', true);
-        var v5: boolean = this.v.emit('click', 1, '1', true, new Date());
-    }
-
-    on() {
-        var fn = () => console.log(1);
-        var v1 = this.v.on('click', fn);
-        var v2 = this.v.on('click', fn, this);
-    }
-
-    once() {
-        var fn = () => console.log(1);
-        var v1 = this.v.once('click', fn);
-        var v2 = this.v.once('click', fn, this);
-    }
-
-    removeListener() {
-        var fn = () => console.log(1);
-        var v1 = this.v.removeListener('click', fn);
-        var v2 = this.v.removeListener('click', fn, true);
-    }
-
-    removeAllListeners() {
-        var v1 = this.v.removeAllListeners('click');
-    }
-
-    off() {
-        var fn = () => console.log(1);
-        var v1 = this.v.off('click', fn);
-        var v2 = this.v.off('click', fn, true);
-    }
-
-    addListener() {
-        var fn = () => console.log(1);
-        var v1 = this.v.addListener('click', fn);
-        var v2 = this.v.addListener('click', fn, this);
-    }
-
-    setMaxListeners() {
-        var v1 = this.v.setMaxListeners();
+    test() {
+        return this;
     }
 }
 
+const ee: TestEmitter = new TestEmitter();
 
-describe('EventEmitter', function tests() {
-  'use strict';
+// EventEmitter.prefixed
+// should be boolean or string static property
+const prefix = EventEmitter.prefixed;
+if (typeof prefix === 'boolean') {
+    console.log(prefix.valueOf());
+} else {
+    console.log(prefix.length);
+}
 
-  it('exposes a `prefixed` property', function () {
-    assume(EventEmitter.prefixed).is.either([false, '~']);
-  });
-
-  it('inherits when used with require(util).inherits', function () {
-    class Beast extends EventEmitter {
-      /* rawr, i'm a beast */
+// EventEmitter.eventNames()
+// should return array of strings or symbols
+ee.eventNames().every((event) => {
+    if (typeof event === 'symbol') {
+        return false;
+    } else {
+        return event.length > 0;
     }
-
-    class BeastES6 extends EventEmitter3ImportedAsES6Module {
-      /* rawr, i'm a beast */
-    }
-
-    util.inherits(Beast, EventEmitter);
-
-    var moop = new Beast()
-      , meap = new Beast();
-
-    assume(moop).is.instanceOf(Beast);
-    assume(moop).is.instanceOf(EventEmitter);
-
-    moop.listeners();
-    meap.listeners();
-
-    moop.on('data', function () {
-      throw new Error('I should not emit');
-    });
-
-    meap.emit('data', 'rawr');
-    meap.removeListener('foo');
-    meap.removeAllListeners();
-  });
-
-  describe('EventEmitter#emit', function () {
-    it('should return false when there are not events to emit', function () {
-      var e = new EventEmitter();
-
-      assume(e.emit('foo')).equals(false);
-      assume(e.emit('bar')).equals(false);
-    });
-
-    it('emits with context', function (done) {
-      var context = { bar: 'baz' }
-        , e = new EventEmitter();
-
-      e.on('foo', function (bar: string) {
-        assume(bar).equals('bar');
-        assume(this).equals(context);
-
-        done();
-      }, context).emit('foo', 'bar');
-    });
-
-    it('emits with context, multiple arguments (force apply)', function (done) {
-      var context = { bar: 'baz' }
-        , e = new EventEmitter();
-
-      e.on('foo', function (bar: string) {
-        assume(bar).equals('bar');
-        assume(this).equals(context);
-
-        done();
-      }, context).emit('foo', 'bar', 1,2,3,4,5,6,7,8,9,0);
-    });
-
-    it('can emit the function with multiple arguments', function () {
-      var e = new EventEmitter();
-
-      for(var i = 0; i < 100; i++) {
-        (function (j: number) {
-          for (var i = 0, args: number[] = []; i < j; i++) {
-            args.push(j);
-          }
-
-          e.once('args', function () {
-            assume(arguments.length).equals(args.length);
-          });
-
-          e.emit.apply(e, (['args'] as any[]).concat(args));
-        })(i);
-      }
-    });
-
-    it('can emit the function with multiple arguments, multiple listeners', function () {
-      var e = new EventEmitter();
-
-      for(var i = 0; i < 100; i++) {
-        (function (j: number) {
-          for (var i = 0, args: number[] = []; i < j; i++) {
-            args.push(j);
-          }
-
-          e.once('args', function () {
-            assume(arguments.length).equals(args.length);
-          });
-
-          e.once('args', function () {
-            assume(arguments.length).equals(args.length);
-          });
-
-          e.once('args', function () {
-            assume(arguments.length).equals(args.length);
-          });
-
-          e.once('args', function () {
-            assume(arguments.length).equals(args.length);
-          });
-
-          e.emit.apply(e, (['args'] as any[]).concat(args));
-        })(i);
-      }
-    });
-
-    it('emits with context, multiple listeners (force loop)', function () {
-      var e = new EventEmitter();
-
-      e.on('foo', function (bar: string) {
-        assume(this).eqls({ foo: 'bar' });
-        assume(bar).equals('bar');
-      }, { foo: 'bar' });
-
-      e.on('foo', function (bar: string) {
-        assume(this).eqls({ bar: 'baz' });
-        assume(bar).equals('bar');
-      }, { bar: 'baz' });
-
-      e.emit('foo', 'bar');
-    });
-
-    it('emits with different contexts', function () {
-      var e = new EventEmitter()
-        , pattern = '';
-
-      function writer() {
-        pattern += this;
-      }
-
-      e.on('write', writer, 'foo');
-      e.on('write', writer, 'baz');
-      e.once('write', writer, 'bar');
-      e.once('write', writer, 'banana');
-
-      e.emit('write');
-      assume(pattern).equals('foobazbarbanana');
-    });
-
-    it('should return true when there are events to emit', function (done) {
-      var e = new EventEmitter();
-
-      e.on('foo', function () {
-        process.nextTick(done);
-      });
-
-      assume(e.emit('foo')).equals(true);
-      assume(e.emit('foob')).equals(false);
-    });
-
-    it('receives the emitted events', function (done) {
-      var e = new EventEmitter();
-
-      e.on('data', function (a: string, b: any, c: Date, d: void, undef: void) {
-        assume(a).equals('foo');
-        assume(b).equals(e);
-        assume(c).is.instanceOf(Date);
-        assume(undef).equals(undefined);
-        assume(arguments.length).equals(3);
-
-        done();
-      });
-
-      e.emit('data', 'foo', e, new Date());
-    });
-
-    it('emits to all event listeners', function () {
-      var e = new EventEmitter()
-        , pattern: string[] = [];
-
-      e.on('foo', function () {
-        pattern.push('foo1');
-      });
-
-      e.on('foo', function () {
-        pattern.push('foo2');
-      });
-
-      e.emit('foo');
-
-      assume(pattern.join(';')).equals('foo1;foo2');
-    });
-
-    (function each(keys: string[]) {
-      var key = keys.shift();
-
-      if (!key) return;
-
-      it('can store event which is a known property: '+ key, function (next) {
-        var e = new EventEmitter();
-
-        e.on(key, function (key: string) {
-          assume(key).equals(key);
-          next();
-        }).emit(key, key);
-      });
-
-      each(keys);
-    })([
-      'hasOwnProperty',
-      'constructor',
-      '__proto__',
-      'toString',
-      'toValue',
-      'unwatch',
-      'watch'
-    ]);
-  });
-
-  describe('EventEmitter#listeners', function () {
-    it('returns an empty array if no listeners are specified', function () {
-      var e = new EventEmitter();
-
-      assume(e.listeners('foo')).is.a('array');
-      assume(e.listeners('foo').length).equals(0);
-    });
-
-    it('returns an array of function', function () {
-       var e = new EventEmitter();
-
-       function foo() {}
-
-       e.on('foo', foo);
-       assume(e.listeners('foo')).is.a('array');
-       assume(e.listeners('foo').length).equals(1);
-       assume(e.listeners('foo')).deep.equals([foo]);
-    });
-
-    it('is not vulnerable to modifications', function () {
-      var e = new EventEmitter();
-
-      function foo() {}
-
-      e.on('foo', foo);
-
-      assume(e.listeners('foo')).deep.equals([foo]);
-
-      e.listeners('foo').length = 0;
-      assume(e.listeners('foo')).deep.equals([foo]);
-    });
-
-    it('can return a boolean as indication if listeners exist', function () {
-      var e = new EventEmitter();
-
-      function foo() {}
-
-      e.once('once', foo);
-      e.once('multiple', foo);
-      e.once('multiple', foo);
-      e.on('on', foo);
-      e.on('multi', foo);
-      e.on('multi', foo);
-
-      assume(e.listeners('foo', true)).equals(false);
-      assume(e.listeners('multiple', true)).equals(true);
-      assume(e.listeners('on', true)).equals(true);
-      assume(e.listeners('multi', true)).equals(true);
-
-      e.removeAllListeners();
-
-      assume(e.listeners('multiple', true)).equals(false);
-      assume(e.listeners('on', true)).equals(false);
-      assume(e.listeners('multi', true)).equals(false);
-    });
-  });
-
-  describe('EventEmitter#once', function () {
-    it('only emits it once', function () {
-      var e = new EventEmitter()
-        , calls = 0;
-
-      e.once('foo', function () {
-        calls++;
-      });
-
-      e.emit('foo');
-      e.emit('foo');
-      e.emit('foo');
-      e.emit('foo');
-      e.emit('foo');
-
-      assume(e.listeners('foo').length).equals(0);
-      assume(calls).equals(1);
-    });
-
-    it('only emits once if emits are nested inside the listener', function () {
-      var e = new EventEmitter()
-        , calls = 0;
-
-      e.once('foo', function () {
-        calls++;
-        e.emit('foo');
-      });
-
-      e.emit('foo');
-      assume(e.listeners('foo').length).equals(0);
-      assume(calls).equals(1);
-    });
-
-    it('only emits once for multiple events', function () {
-      var e = new EventEmitter()
-        , multi = 0
-        , foo = 0
-        , bar = 0;
-
-      e.once('foo', function () {
-        foo++;
-      });
-
-      e.once('foo', function () {
-        bar++;
-      });
-
-      e.on('foo', function () {
-        multi++;
-      });
-
-      e.emit('foo');
-      e.emit('foo');
-      e.emit('foo');
-      e.emit('foo');
-      e.emit('foo');
-
-      assume(e.listeners('foo').length).equals(1);
-      assume(multi).equals(5);
-      assume(foo).equals(1);
-      assume(bar).equals(1);
-    });
-
-    it('only emits once with context', function (done) {
-      var context = { foo: 'bar' }
-        , e = new EventEmitter();
-
-      e.once('foo', function (bar: string) {
-        assume(this).equals(context);
-        assume(bar).equals('bar');
-
-        done();
-      }, context).emit('foo', 'bar');
-    });
-  });
-
-  describe('EventEmitter#removeListener', function () {
-    it('should only remove the event with the specified function', function () {
-      var e = new EventEmitter();
-
-      function bar() {}
-      e.on('foo', function () {});
-      e.on('bar', function () {});
-      e.on('bar', bar);
-
-      assume(e.removeListener('foo', bar)).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.listeners('bar').length).equals(2);
-
-      assume(e.removeListener('foo')).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-      assume(e.listeners('bar').length).equals(2);
-
-      assume(e.removeListener('bar', bar)).equals(e);
-      assume(e.listeners('bar').length).equals(1);
-      assume(e.removeListener('bar')).equals(e);
-      assume(e.listeners('bar').length).equals(0);
-    });
-
-    it('should only remove once events when using the once flag', function () {
-      var e = new EventEmitter();
-
-      function foo() {}
-      e.on('foo', foo);
-
-      assume(e.removeListener('foo', function () {}, undefined, true)).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.removeListener('foo', foo, undefined, true)).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.removeListener('foo', foo)).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-
-      e.on('foo', foo);
-      e.once('foo', foo);
-
-      assume(e.removeListener('foo', function () {}, undefined, true)).equals(e);
-      assume(e.listeners('foo').length).equals(2);
-      assume(e.removeListener('foo', foo, undefined, true)).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-
-      e.once('foo', foo);
-
-      assume(e.removeListener('foo', foo)).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-    });
-
-    it('should only remove listeners matching the correct context', function () {
-      var e = new EventEmitter()
-        , context = { foo: 'bar' };
-
-      function foo() {}
-      function bar() {}
-      e.on('foo', foo, context);
-
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.removeListener('foo', function () {}, context)).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.removeListener('foo', foo, { baz: 'quux' })).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.removeListener('foo', foo, context)).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-
-      e.on('foo', foo, context);
-      e.on('foo', bar);
-
-      assume(e.listeners('foo').length).equals(2);
-      assume(e.removeListener('foo', foo, { baz: 'quux' })).equals(e);
-      assume(e.listeners('foo').length).equals(2);
-      assume(e.removeListener('foo', foo, context)).equals(e);
-      assume(e.listeners('foo').length).equals(1);
-      assume(e.listeners('foo')[0]).equals(bar);
-
-      e.on('foo', foo, context);
-
-      assume(e.listeners('foo').length).equals(2);
-      assume(e.removeAllListeners('foo')).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-    });
-  });
-
-  describe('EventEmitter#removeAllListeners', function () {
-    it('removes all events for the specified events', function () {
-      var e = new EventEmitter();
-
-      e.on('foo', function () { throw new Error('oops'); });
-      e.on('foo', function () { throw new Error('oops'); });
-      e.on('bar', function () { throw new Error('oops'); });
-      e.on('aaa', function () { throw new Error('oops'); });
-
-      assume(e.removeAllListeners('foo')).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-      assume(e.listeners('bar').length).equals(1);
-      assume(e.listeners('aaa').length).equals(1);
-
-      assume(e.removeAllListeners('bar')).equals(e);
-      assume(e.removeAllListeners('aaa')).equals(e);
-
-      assume(e.emit('foo')).equals(false);
-      assume(e.emit('bar')).equals(false);
-      assume(e.emit('aaa')).equals(false);
-    });
-
-    it('just nukes the fuck out of everything', function () {
-      var e = new EventEmitter();
-
-      e.on('foo', function () { throw new Error('oops'); });
-      e.on('foo', function () { throw new Error('oops'); });
-      e.on('bar', function () { throw new Error('oops'); });
-      e.on('aaa', function () { throw new Error('oops'); });
-
-      assume(e.removeAllListeners()).equals(e);
-      assume(e.listeners('foo').length).equals(0);
-      assume(e.listeners('bar').length).equals(0);
-      assume(e.listeners('aaa').length).equals(0);
-
-      assume(e.emit('foo')).equals(false);
-      assume(e.emit('bar')).equals(false);
-      assume(e.emit('aaa')).equals(false);
-    });
-  });
-
-  describe('#setMaxListeners', function () {
-    it('is a function', function () {
-      var e = new EventEmitter();
-
-      assume(e.setMaxListeners).is.a('function');
-    });
-
-    it('returns self when called', function () {
-      var e = new EventEmitter();
-
-      assume(e.setMaxListeners()).to.equal(e);
-    });
-  });
 });
+
+// EventEmitter.listeners()
+// should return array of functions
+ee.listeners(eventName).map((listener) => {
+    return listener.bind(this);
+});
+// should accept symbol as event name
+ee.listeners(eventSymbol).map((listener) => {
+    return listener.bind(this);
+});
+// should return boolean with 'exists' flag
+const hasListeners: boolean = ee.listeners(eventName, true);
+
+// EventEmitter.emit()
+// should support any number of arguments
+ee.emit(eventName, 1, true, {}, [], 'test', Symbol(), null);
+// should accept symbol as event name
+ee.emit(eventSymbol);
+
+// EventEmitter.addListener() and EventEmitter.on()
+// should accept function
+ee.on(eventName, fn);
+ee.addListener(eventName, fn);
+// should accept optional context argument
+ee.on(eventName, fn, this);
+ee.addListener(eventName, fn, this);
+// should accept symbol as event name
+ee.on(eventSymbol, fn);
+ee.addListener(eventSymbol, fn);
+// should support fluent interface
+ee.on(eventSymbol, fn).test();
+ee.addListener(eventSymbol, fn).test();
+
+// EventEmitter.once()
+// should accept event name and function
+ee.once(eventName, fn);
+// should accept optional context argument
+ee.once(eventName, fn, this);
+ee.once(eventName, fn, {});
+// should accept symbol as event name
+ee.once(eventSymbol, fn);
+// should support fluent interface
+ee.once(eventSymbol, fn).test();
+
+// EventEmitter.removeListener() and EventEmitter.off()
+// should accept event name
+ee.removeListener(eventName);
+ee.off(eventName);
+// should accept optional function
+ee.removeListener(eventName, fn);
+ee.off(eventName, fn);
+// should accept optional context argument
+ee.removeListener(eventName, fn, {});
+ee.off(eventName, fn, {});
+// should accept optional boolean flag for removing listeners added with `EventEmitter.once()`
+ee.removeListener(eventName, fn, null, true);
+ee.off(eventName, fn, null, true);
+// should accept symbol as event name
+ee.removeListener(eventSymbol);
+ee.off(eventSymbol);
+// should support fluent interface
+ee.removeListener(eventName).test();
+ee.off(eventName).test();
+
+// EventEmitter.removeAllListeners()
+// should not require any arguments
+ee.removeAllListeners();
+// should accept optional event name
+ee.removeAllListeners(eventName);
+// should accept symbol as event name
+ee.removeAllListeners(eventSymbol);
+// should support fluent interface
+ee.removeAllListeners(eventName).test();
+
+// EventEmitter.setMaxListeners()
+// should support fluent interface
+ee.setMaxListeners().test();

eventemitter3/eventemitter3-tests.ts.tscparams

@@ -0,0 +1 @@
+-m commonjs

eventemitter3/index.d.ts

@@ -1,6 +1,6 @@
-// Type definitions for EventEmitter3 1.1.1
+// Type definitions for EventEmitter3 1.2.0
 // Project: https://github.com/primus/eventemitter3
-// Definitions by: Yuichi Murata <https://github.com/mrk21>, Leon Yu <https://github.com/leonyu>
+// Definitions by: Yuichi Murata <https://github.com/mrk21>, Leon Yu <https://github.com/leonyu>, Boriss Nazarovs <https://github.com/Stubb0rn>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 export = EventEmitter;
@@ -10,6 +10,10 @@ declare namespace EventEmitter {
 }
 
 type self = EventEmitter;
+/**
+ * Minimal EventEmitter interface that is molded against the Node.js
+ * EventEmitter interface.
+ */
 declare class EventEmitter {
     static prefixed: string | boolean;
 
@@ -28,96 +32,91 @@ declare class EventEmitter {
     constructor();
 
     /**
-     * Return a list of assigned event listeners.
+     * Return an array listing the events for which the emitter has registered listeners.
      *
-     * @param {String} event The events that should be listed.
-     * @returns {Array}
-     * @api public
+     * @returns {(string | symbol)[]}
      */
-    listeners(event?: string): Function[];
+    eventNames(): (string | symbol)[];
 
     /**
-     * Return a list of assigned event listeners.
+     * Return the listeners registered for a given event.
      *
-     * @param {String} event The events that should be listed.
-     * @param {Boolean} exists We only need to know if there are listeners.
-     * @returns {Boolean}
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @returns {Function[]}
      */
-    listeners(event: string, param: boolean): boolean;
+    listeners(event: string | symbol): Function[];
 
     /**
-     * Emit an event to all registered event listeners.
+     * Check if there listeners for a given event.
+     * If `exists` argument is not `true` lists listeners.
      *
-     * @param {String} event The name of the event.
-     * @returns {Boolean} Indication if we've emitted an event.
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @param {boolean} exists Only check if there are listeners.
+     * @returns {boolean}
      */
-    emit(event: string, ...args: any[]): boolean;
+    listeners(event: string | symbol, exists: boolean): boolean;
 
     /**
-     * Register a new EventListener for the given event.
+     * Calls each of the listeners registered for a given event.
      *
-     * @param {String} event Name of the event.
-     * @param {Function} fn Callback function.
-     * @param {Mixed} [context=this] The context of the function.
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @param {...*} args Arguments that are passed to registered listeners
+     * @returns {boolean} `true` if the event had listeners, else `false`.
      */
-    on(event: string, fn: Function, context?: any): EventEmitter;
+    emit(event: string | symbol, ...args: any[]): boolean;
 
     /**
-     * Add an EventListener that's only called once.
+     * Add a listener for a given event.
      *
-     * @param {String} event Name of the event.
-     * @param {Function} fn Callback function.
-     * @param {Mixed} [context=this] The context of the function.
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
      */
-    once(event: string, fn: Function, context?: any): EventEmitter;
+    on(event: string | symbol, fn: Function, context?: any): this;
 
     /**
-     * Remove event listeners.
+     * Add a one-time listener for a given event.
      *
-     * @param {String} event The event we want to remove.
-     * @param {Function} fn The listener that we need to find.
-     * @param {Mixed} context Only remove listeners matching this context.
-     * @param {Boolean} once Only remove once listeners.
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
      */
-    removeListener(event: string, fn?: Function, context?: any, once?: boolean): EventEmitter;
+    once(event: string | symbol, fn: Function, context?: any): this;
 
     /**
-     * Remove all listeners or only the listeners for the specified event.
+     * Remove the listeners of a given event.
      *
-     * @param {String} event The event want to remove all listeners for.
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @param {Function} fn Only remove the listeners that match this function.
+     * @param {*} context Only remove the listeners that have this context.
+     * @param {boolean} once Only remove one-time listeners.
+     * @returns {EventEmitter} `this`.
      */
-    removeAllListeners(event?: string): EventEmitter;
+    removeListener(event: string | symbol, fn?: Function, context?: any, once?: boolean): this;
 
     /**
-     * Remove event listeners.
+     * Remove all listeners, or those of the specified event.
      *
-     * @param {String} event The event we want to remove.
-     * @param {Function} fn The listener that we need to find.
-     * @param {Mixed} context Only remove listeners matching this context.
-     * @param {Boolean} once Only remove once listeners.
-     * @api public
+     * @param {(string | symbol)} event The event name.
+     * @returns {EventEmitter} `this`.
      */
-    off(event: string, fn?: Function, context?: any, once?: boolean): EventEmitter;
+    removeAllListeners(event?: string | symbol): this;
 
     /**
-     * Register a new EventListener for the given event.
-     *
-     * @param {String} event Name of the event.
-     * @param {Function} fn Callback function.
-     * @param {Mixed} [context=this] The context of the function.
-     * @api public
+     * Alias method for `removeListener`
      */
-    addListener(event: string, fn: Function, context?: any): EventEmitter;
+    off(event: string | symbol, fn?: Function, context?: any, once?: boolean): this;
+
+    /**
+     * Alias method for `on`
+     */
+    addListener(event: string | symbol, fn: Function, context?: any): this;
 
     /**
      * This function doesn't apply anymore.
      * @deprecated
      */
-    setMaxListeners(): EventEmitter;
+    setMaxListeners(): this;
 }

fusioncharts/fusioncharts-tests.ts

@@ -0,0 +1,49 @@
+FusionCharts.addEventListener('ready',(eventObject)=>{
+    eventObject.stopPropagation();
+});
+
+FusionCharts.ready((fusioncharts)=>{
+
+});
+
+FusionCharts.version;
+
+FusionCharts('chartId').render();;
+
+FusionCharts["debugger"].enable(true);
+
+let chartData ={
+    type: 'column2d',
+    renderAt: 'chart-container',
+    width: '450',
+    height: '200',
+    dataFormat: 'json',
+    dataSource: {
+        "chart": {
+            "caption": "Monthly revenue for last year",
+            "subCaption": "Harry's SuperMart",
+        },
+        "data": [{
+            "label": "Jan",
+            "value": "420000"
+        }, {
+            "label": "Feb",
+            "value": "810000"
+        }
+        ]
+    }
+};
+
+let chart = new FusionCharts(chartData);
+chart.render();
+chart.isActive();
+chart.addEventListener('ready',function(eventObject){
+    eventObject.type;
+});
+chart.chartType();
+chart.addVariable();
+chart.clone();
+chart.zoomTo(0,3);
+chart.zoomOut();
+chart.setJSONData(chartData);
+chart.ref;

fusioncharts/index.d.ts

@@ -0,0 +1,297 @@
+// Type definitions for FusionCharts 3.11.2
+// Project: http://www.fusioncharts.com
+// Definitions by: Shivaraj KV <https://github.com/shivarajkv>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+declare namespace FusionCharts {
+
+    type ChartDataFormats = 'json' | 'jsonurl' | 'csv' | 'xml' | 'xmlurl';
+
+    type ImageHAlign = 'left' | 'right' | 'middle';
+
+    type ImageVAlign = 'top' | 'bottom' | 'middle';
+
+    interface EventObject {
+        type: string;
+
+        eventId: number;
+
+        sender: FusionCharts;
+
+        cancelled: boolean;
+
+        stopPropagation: () => void;
+
+        prevented: boolean;
+
+        preventDefault: () => void;
+
+        detached: boolean;
+
+        detachHandler: () => void;
+    }
+
+    interface ChartObject {
+
+        type?: string;
+
+        id?: string;
+
+        width?: number | string;
+
+        height?: number | string;
+
+        renderAt?: string;
+
+        dataFormat?: ChartDataFormats;
+
+        dataSource?: string | {};
+
+        events?: {};
+
+        link?: {};
+
+        showDataLoadingMessage?: boolean;
+
+        showChartLoadingMessage?: boolean;
+
+        baseChartMessageFont?: string;
+
+        baseChartMessageFontSize?: string;
+
+        baseChartMessageColor?: string;
+
+        dataLoadStartMessage?: string;
+
+        dataLoadErrorMessage?: string;
+
+        dataInvalidMessage?: string;
+
+        dataEmptyMessage?: string;
+
+        typeNotSupportedMessage?: string;
+
+        loadMessage?: string;
+
+        renderErrorMessage?: string;
+
+        containerBackgroundColor?: string;
+
+        containerBackgroundOpacity?: number;
+
+        containerClassName?: string;
+
+        baseChartMessageImageHAlign?: ImageHAlign;
+
+        dataLoadErrorMessageImageVAlign?: ImageVAlign;
+
+        dataLoadErrorMessageImageAlpha?: number;
+
+        dataLoadErrorMessageImageScale?: number;
+
+        dataLoadStartMessageImageHAlign?: ImageHAlign;
+
+        dataLoadStartMessageImageVAlign?: ImageVAlign;
+
+        dataLoadStartMessageImageAlpha?: number;
+
+        dataLoadStartMessageImageScale?: number;
+
+        dataInvalidMessageImageHAlign?: ImageHAlign;
+
+        dataInvalidMessageImageVAlign?: ImageVAlign;
+
+        dataInvalidMessageImageAlpha?: number;
+
+        dataInvalidMessageImageScale?: number;
+
+        dataEmptyMessageImageHAlign?: ImageHAlign;
+
+        dataEmptyMessageImageVAlign?: ImageVAlign;
+
+        dataEmptyMessageImageAlpha?: number;
+
+        dataEmptyMessageImageScale?: number;
+
+        renderErrorMessageImageHAlign?: ImageHAlign;
+
+        renderErrorMessageImageVAlign?: ImageVAlign;
+
+        renderErrorMessageImageAlpha?: number;
+
+        renderErrorMessageImageScale?: number;
+
+        loadMessageImageHAlign?: ImageHAlign;
+
+        loadMessageImageVAlign?: ImageVAlign;
+
+        loadMessageImageAlpha?: number;
+
+        loadMessageImageScale?: number;
+    }
+
+    interface Debugger {
+        outputFormat(format: any): void;
+
+        outputTo(callback: (message: any) => any): void;
+
+        enable(state:any,outputTo?:(message: any) =>any,outputFormat?:any):void
+
+        enableFirebugLite():any;
+    }
+
+    interface FusionCharts {
+        clone(overrides?: {}, argsOnly?: boolean): any;
+
+        isActive(): boolean;
+
+        chartType(value?: string, options?: any): string;
+
+        addEventListener(type: string | string[], listener: (eventObject?: EventObject, eventArgs?: {}) => void): void;
+
+        removeEventListener(type: string | string[], listener: (eventObject?: EventObject, eventArgs?: {}) => void): void;
+
+        configureLink(param: {} | any[], level?: number): void;
+
+        setChartAttribute(attributes: ChartObject | String, value?: string): void;
+
+        getChartAttribute(attribute?: string | string[]): ChartObject;
+
+        getXMLData(): any;
+
+        setXMLData(data: string | {}): void;
+
+        setXMLUrl(url: string): void;
+
+        setChartDataUrl(url: string, format: ChartDataFormats): void;
+
+        setChartData(data: string | {}, format: ChartDataFormats): void;
+
+        getChartData(format: ChartDataFormats): any;
+
+        dataReady(available?: boolean): boolean;
+
+        feedData(stream: string): void;
+
+        getData(): any;
+
+        getDataWithId(): any;
+
+        setData(value: number, label: string): void;
+
+        stopUpdate(): void;
+
+        restartUpdate(): void;
+
+        isUpdateActive(): boolean;
+
+        clearChart(): void;
+
+        getSWFHTML(): any;
+
+        addVariable(): void;
+
+        getXML(): any;
+
+        setDataXML(data: string | {}): void;
+
+        setDataURL(url: string): void;
+
+        hasRendered(): boolean;
+
+        setTransparent(transparency?: boolean): void;
+
+        isPlotItemSliced(index: number): boolean;
+
+        slicePlotItem(index: number, slice: boolean): void;
+
+        centerLabel(labelText: string, options?: {}): void;
+
+        startingAngle(angle?: number, relative?: boolean): void;
+
+        zoomOut(): void;
+
+        zoomTo(startIndex: number, endIndex: number): void;
+
+        resetChart(): void;
+
+        setZoomMode(yes: boolean): void;
+
+        getViewStartIndex(): number;
+
+        getViewEndIndex(): number;
+
+        print(options?: {}): void;
+
+        exportChart(options?: {}): void;
+
+        getSVGString(): string;
+
+        lockResize(state: boolean): boolean;
+
+        showChartMessage(text: string, modal?: boolean, cancelable?: boolean): void;
+
+        getJSONData(): JSON;
+
+        setJSONData(data: string | {}): void;
+
+        setJSONUrl(url: string): void;
+
+        getCSVData(): any;
+
+        getDataAsCSV(): any;
+
+        render(containerElement?: string | Element, insertMode?: string, callback?: () => any): FusionCharts;
+
+        resizeTo(width: number | string, height: number | string): any;
+
+        dispose(): void;
+
+        configure(options: {}): void;
+
+        ref: {};
+
+    }
+
+    interface FusionChartStatic {
+        new (chartObject: ChartObject|{}): FusionCharts;
+
+        (chartId: string): FusionCharts;
+
+        getObjectReference(elementId: string): Element;
+
+        addEventListener(type: string | string[], listener: (eventObject?: EventObject, eventArgs?: {}) => void): void;
+
+        removeEventListener(type: string | string[], listener: (eventObject?: EventObject, eventArgs?: {}) => void): void;
+
+        ready(callback: (fusionChartStatic?: FusionChartStatic) => any, context?: any): FusionChartStatic;
+
+        transcodeData(data: string | {}, source: ChartDataFormats, target: ChartDataFormats, advanced: boolean): any;
+
+        batchExport(options: {}): void;
+
+        formatNumber(num: number, type?: string, config?: {}): Element;
+
+        setCurrentRenderer(name: string): void
+
+        getCurrentRenderer(): string;
+
+        render(options?: ChartObject, callback?: () => any): FusionCharts;
+
+        version: string[];
+
+        items: {};
+
+        options: {};
+
+        debugger:Debugger;
+
+
+    }
+
+}
+
+declare var FusionCharts: FusionCharts.FusionChartStatic;
+export = FusionCharts;
+export as namespace FusionCharts;

fusioncharts/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "fusioncharts-tests.ts"
+    ]
+}

gapi.analytics/gapi.analytics-tests.ts

@@ -0,0 +1,63 @@
+// Type definitions for Google Analytics API
+
+function test_namespace() {
+	var analytics : boolean = gapi.client.analytics instanceof Object;
+
+	var provisioning : boolean = gapi.client.analytics.provisioning.createAccountTicket instanceof Function;
+	analytics = analytics && provisioning;
+
+	var data : boolean = gapi.client.analytics.data.ga.get instanceof Function;
+	data = data && gapi.client.analytics.data.mcf.get instanceof Function;
+	data = data && gapi.client.analytics.data.realtime.get instanceof Function;
+	analytics = analytics && data;
+
+	interface AnalyticsParameter {
+		"type"              ?: string;
+		"description"       ?: string;
+		"default"           ?: string;
+		"enum"              ?: string[];
+		"enumDescriptions"  ?: string[];
+		"location"          ?: string;
+	}
+    var kBI : AnalyticsParameter = gapi.client.analytics.kB.parameters.alt;
+	var kB = !!kBI;
+    kBI = gapi.client.analytics.kB.parameters.fields;
+	kB = kB && !!kBI;
+    kBI = gapi.client.analytics.kB.parameters.key;
+	kB = kB && !!kBI;
+    kBI = gapi.client.analytics.kB.parameters.oauth_token;
+	kB = kB && !!kBI;
+    kBI = gapi.client.analytics.kB.parameters.prettyPrint;
+	kB = kB && !!kBI;
+    kBI = gapi.client.analytics.kB.parameters.quotaUser;
+	kB = kB && !!kBI;
+    kBI = gapi.client.analytics.kB.parameters.userIP;
+	kB = kB && !!kBI;
+	analytics = analytics && kB;
+
+	var management : boolean = gapi.client.analytics.management.accountSummaries.list instanceof Function;
+	management = management && gapi.client.analytics.management.accountUserLinks.list instanceof Function;
+	management = management && gapi.client.analytics.management.accounts.list instanceof Function;
+	management = management && gapi.client.analytics.management.customDataSources.list instanceof Function;
+	management = management && gapi.client.analytics.management.customDimensions.list instanceof Function;
+	management = management && gapi.client.analytics.management.customMetrics.list instanceof Function;
+	management = management && gapi.client.analytics.management.experiments.list instanceof Function;
+	management = management && gapi.client.analytics.management.filters.list instanceof Function;
+	management = management && gapi.client.analytics.management.goals.list instanceof Function;
+	management = management && gapi.client.analytics.management.profileFilterLinks.list instanceof Function;
+	management = management && gapi.client.analytics.management.profileUserLinks.list instanceof Function;
+	management = management && gapi.client.analytics.management.profiles.list instanceof Function;
+	management = management && gapi.client.analytics.management.remarketingAudience.list instanceof Function;
+	management = management && gapi.client.analytics.management.segments.list instanceof Function;
+	management = management && gapi.client.analytics.management.unsampledReports.list instanceof Function;
+	management = management && gapi.client.analytics.management.uploads.list instanceof Function;
+	management = management && gapi.client.analytics.management.webPropertyAdWordsLinks.list instanceof Function;
+	management = management && gapi.client.analytics.management.webproperties.list instanceof Function;
+	management = management && gapi.client.analytics.management.webpropertyUserLinks.list instanceof Function;
+	analytics = analytics && management;
+
+	var metadata : boolean = gapi.client.analytics.metadata.column.list instanceof Function;
+	analytics = analytics && metadata;
+
+	return analytics;
+}

gapi.analytics/index.d.ts

@@ -0,0 +1,126 @@
+// Type definitions for Google Analytics API
+// Project: https://developers.google.com/analytics/devguides/reporting/core/v4/
+// Definitions by: César Costas <https://github.com/gatsbimantico>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="gapi" />
+
+declare namespace gapi.client.analytics {}
+declare namespace gapi.client.analytics.provisioning {
+    export function createAccountTicket() : Promise<any>;
+}
+
+interface DataQuery {
+    "ids"                   ?: string;
+    "start-date"            ?: string;
+    "30daysAgo"             ?: string;
+    "end-date"              ?: string;
+    "yesterday"             ?: string;
+    "metrics"               ?: string;
+    "dimensions"            ?: string;
+    "sort"                  ?: string;
+    "filters"               ?: string;
+    "segment"               ?: string;
+    "samplingLevel"         ?: string;
+    "include-empty-rows"    ?: string;
+    "start-index"           ?: string;
+    "max-results"           ?: string;
+}
+declare namespace gapi.client.analytics.data {}
+declare namespace gapi.client.analytics.data.ga {
+    export function get(data ?: DataQuery) : Promise<any>;
+}
+declare namespace gapi.client.analytics.data.mcf {
+    export function get(data ?: DataQuery) : Promise<any>;
+}
+declare namespace gapi.client.analytics.data.realtime {
+    export function get(data ?: DataQuery) : Promise<any>;
+}
+
+declare namespace gapi.client.analytics.kB {}
+declare namespace gapi.client.analytics.kB.parameters {
+	export interface AnalyticsParameter {
+		"type"              ?: string;
+		"description"       ?: string;
+		"default"           ?: string;
+		"enum"              ?: string[];
+		"enumDescriptions"  ?: string[];
+		"location"          ?: string;
+	}
+	export class alt implements AnalyticsParameter {}
+	export class fields implements AnalyticsParameter {}
+	export class key implements AnalyticsParameter {}
+	export class oauth_token implements AnalyticsParameter {}
+	export class prettyPrint implements AnalyticsParameter {}
+	export class quotaUser implements AnalyticsParameter {}
+	export class userIP implements AnalyticsParameter {}
+}
+
+interface View {
+    accountId       ?: string;
+    webPropertyId   ?: string;
+    webViewId       ?: string;
+}
+declare namespace gapi.client.analytics.management {}
+declare namespace gapi.client.analytics.management.accountSummaries {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.accountUserLinks {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.accounts {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.customDataSources {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.customDimensions {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.customMetrics {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.experiments {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.filters {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.goals {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.profileFilterLinks {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.profileUserLinks {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.profiles {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.remarketingAudience {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.segments {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.unsampledReports {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.uploads {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.webPropertyAdWordsLinks {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.webproperties {
+    export function list(view ?: View) : Promise<any>;
+}
+declare namespace gapi.client.analytics.management.webpropertyUserLinks {
+    export function list(view ?: View) : Promise<any>;
+}
+
+declare namespace gapi.client.analytics.metadata {}
+declare namespace gapi.client.analytics.metadata.column {
+    export function list() : Promise<any>;
+}

gapi.analytics/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "gapi.analytics-tests.ts"
+    ]
+}

google-libphonenumber/index.d.ts

@@ -15,11 +15,21 @@ declare namespace libphonenumber {
     interface PhoneNumber {
     }
 
+    export module PhoneNumberUtil {
+        export enum ValidationResult {
+            IS_POSSIBLE,
+            INVALID_COUNTRY_CODE,
+            TOO_SHORT,
+            TOO_LONG
+        }
+    }
+
     export class PhoneNumberUtil {
         static getInstance(): PhoneNumberUtil
         parse(number: string, region: string): PhoneNumber;
         isValidNumber(phoneNumber: PhoneNumber): boolean;
         isPossibleNumber(phoneNumber: PhoneNumber): boolean;
+        isPossibleNumberWithReason(phoneNumber: PhoneNumber): PhoneNumberUtil.ValidationResult;
         isValidNumberForRegion(phoneNumber: PhoneNumber, region: string): boolean;
         getRegionCodeForNumber(phoneNumber: PhoneNumber): string;
         isNANPACountry(regionCode: string): boolean;

graphql/index.d.ts

@@ -2194,7 +2194,7 @@ declare module "graphql/utilities/astFromValue" {
 }
 
 declare module "graphql/utilities/buildASTSchema" {
-    import { Document } from 'graphql/language/ast';
+    import { Document, Location } from 'graphql/language/ast';
     import { Source } from 'graphql/language/source';
     import { GraphQLSchema } from 'graphql/type/schema';
 
@@ -2263,6 +2263,7 @@ declare module "graphql/utilities/concatAST" {
 }
 
 declare module "graphql/utilities/extendSchema" {
+    import { Document } from 'graphql/language/ast';
     import { GraphQLSchema } from 'graphql/type/schema';
 
     /**

highcharts/index.d.ts

@@ -5946,6 +5946,19 @@ declare namespace Highcharts {
          * @since 2.0.5
          */
         showLoading(str?: string): void;
+        /**
+         * A generic function to update any element of the chart. Elements can be enabled and disabled, moved, re-styled,
+         * re-formatted etc.
+         * A special case is configuration objects that take arrays, for example xAxis, yAxis or series. For these collections,
+         * an id option is used to map the new option set to an existing object. If an existing object of the same id is not
+         * found, the first item is updated. So for example, running chart.update with a series item without an id, will cause
+         * the existing chart's first series to be updated.
+         * See also the responsive option set. Switching between responsive.rules basically runs chart.update under the hood.
+         * @param {ChartOptions} option A configuration object for the new chart options as defined in the options section of the API.
+         * @param [boolean] redraw Whether to redraw the chart. Defaults to true.
+         * @since 5.0.0
+         */
+        update(options: ChartOptions, redraw?: boolean): void;
         /**
          * This method is deprecated as of 2.0.1. Updating the chart position after a move operation is no longer necessary.
          * @since 1.2.5

immutable/index.d.ts

@@ -260,11 +260,11 @@ declare namespace Immutable {
      * @see `Map#mergeWith`
      */
     mergeWith(
-      merger: (previous?: T, next?: T, key?: number) => T,
+      merger: (previous: T, next: T, key: number) => T,
       ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeWith(
-      merger: (previous?: T, next?: T, key?: number) => T,
+      merger: (previous: T, next: T, key: number) => T,
       ...iterables: Array<T>[]
     ): List<T>;
 
@@ -278,11 +278,11 @@ declare namespace Immutable {
      * @see `Map#mergeDeepWith`
      */
     mergeDeepWith(
-      merger: (previous?: T, next?: T, key?: number) => T,
+      merger: (previous: T, next: T, key: number) => T,
       ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeDeepWith(
-      merger: (previous?: T, next?: T, key?: number) => T,
+      merger: (previous: T, next: T, key: number) => T,
       ...iterables: Array<T>[]
     ): List<T>;
 
@@ -541,11 +541,11 @@ declare namespace Immutable {
      *
      */
     mergeWith(
-      merger: (previous?: V, next?: V, key?: K) => V,
+      merger: (previous: V, next: V, key: K) => V,
       ...iterables: Iterable<K, V>[]
     ): Map<K, V>;
     mergeWith(
-      merger: (previous?: V, next?: V, key?: K) => V,
+      merger: (previous: V, next: V, key: K) => V,
       ...iterables: {[key: string]: V}[]
     ): Map<string, V>;
 
@@ -572,11 +572,11 @@ declare namespace Immutable {
      *
      */
     mergeDeepWith(
-      merger: (previous?: V, next?: V, key?: K) => V,
+      merger: (previous: V, next: V, key: K) => V,
       ...iterables: Iterable<K, V>[]
     ): Map<K, V>;
     mergeDeepWith(
-      merger: (previous?: V, next?: V, key?: K) => V,
+      merger: (previous: V, next: V, key: K) => V,
       ...iterables: {[key: string]: V}[]
     ): Map<string, V>;
 
@@ -1459,7 +1459,7 @@ declare namespace Immutable {
        *
        */
       mapKeys<M>(
-        mapper: (key?: K, value?: V, iter?: this) => M,
+        mapper: (key: K, value: V, iter: this) => M,
         context?: any
       ): /*this*/Iterable.Keyed<M, V>;
 
@@ -1474,9 +1474,9 @@ declare namespace Immutable {
        */
       mapEntries<KM, VM>(
         mapper: (
-          entry?: [K, V],
-          index?: number,
-          iter?: this
+          entry: [K, V],
+          index: number,
+          iter: this
         ) => [KM, VM],
         context?: any
       ): /*this*/Iterable.Keyed<KM, VM>;
@@ -1641,7 +1641,7 @@ declare namespace Immutable {
        * provided predicate function. Otherwise -1 is returned.
        */
       findIndex(
-        predicate: (value?: T, index?: number, iter?: this) => boolean,
+        predicate: (value: T, index: number, iter: this) => boolean,
         context?: any
       ): number;
 
@@ -1650,7 +1650,7 @@ declare namespace Immutable {
        * provided predicate function. Otherwise -1 is returned.
        */
       findLastIndex(
-        predicate: (value?: T, index?: number, iter?: this) => boolean,
+        predicate: (value: T, index: number, iter: this) => boolean,
         context?: any
       ): number;
     }
@@ -1971,7 +1971,7 @@ declare namespace Immutable {
      *
      */
     map<M>(
-      mapper: (value?: V, key?: K, iter?: this) => M,
+      mapper: (value: V, key: K, iter: this) => M,
       context?: any
     ): /*this*/Iterable<K, M>;
 
@@ -1984,7 +1984,7 @@ declare namespace Immutable {
      *
      */
     filter(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): this;
 
@@ -1997,7 +1997,7 @@ declare namespace Immutable {
      *
      */
     filterNot(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): this;
 
@@ -2033,7 +2033,7 @@ declare namespace Immutable {
      *
      */
     sortBy<C>(
-      comparatorValueMapper: (value?: V, key?: K, iter?: this) => C,
+      comparatorValueMapper: (value: V, key: K, iter: this) => C,
       comparator?: (valueA: C, valueB: C) => number
     ): this;
 
@@ -2044,7 +2044,7 @@ declare namespace Immutable {
      * Note: This is always an eager operation.
      */
     groupBy<G>(
-      grouper: (value?: V, key?: K, iter?: this) => G,
+      grouper: (value: V, key: K, iter: this) => G,
       context?: any
     ): Seq.Keyed<G, this>;
 
@@ -2059,7 +2059,7 @@ declare namespace Immutable {
      * (including the last iteration which returned false).
      */
     forEach(
-      sideEffect: (value?: V, key?: K, iter?: this) => any,
+      sideEffect: (value: V, key: K, iter: this) => any,
       context?: any
     ): number;
 
@@ -2118,7 +2118,7 @@ declare namespace Immutable {
      *
      */
     skipWhile(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): this;
 
@@ -2132,7 +2132,7 @@ declare namespace Immutable {
      *
      */
     skipUntil(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): this;
 
@@ -2158,7 +2158,7 @@ declare namespace Immutable {
      *
      */
     takeWhile(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): this;
 
@@ -2171,7 +2171,7 @@ declare namespace Immutable {
      *
      */
     takeUntil(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): this;
 
@@ -2209,11 +2209,11 @@ declare namespace Immutable {
      * Similar to `iter.map(...).flatten(true)`.
      */
     flatMap<MK, MV>(
-      mapper: (value?: V, key?: K, iter?: this) => Iterable<MK, MV>,
+      mapper: (value: V, key: K, iter: this) => Iterable<MK, MV>,
       context?: any
     ): /*this*/Iterable<MK, MV>;
     flatMap<MK, MV>(
-      mapper: (value?: V, key?: K, iter?: this) => /*iterable-like*/any,
+      mapper: (value: V, key: K, iter: this) => /*iterable-like*/any,
       context?: any
     ): /*this*/Iterable<MK, MV>;
 
@@ -2230,7 +2230,7 @@ declare namespace Immutable {
      * @see `Array#reduce`.
      */
     reduce<R>(
-      reducer: (reduction?: R, value?: V, key?: K, iter?: this) => R,
+      reducer: (reduction: R, value: V, key: K, iter: this) => R,
       initialReduction?: R,
       context?: any
     ): R;
@@ -2242,7 +2242,7 @@ declare namespace Immutable {
      * with `Array#reduceRight`.
      */
     reduceRight<R>(
-      reducer: (reduction?: R, value?: V, key?: K, iter?: this) => R,
+      reducer: (reduction: R, value: V, key: K, iter: this) => R,
       initialReduction?: R,
       context?: any
     ): R;
@@ -2251,7 +2251,7 @@ declare namespace Immutable {
      * True if `predicate` returns true for all entries in the Iterable.
      */
     every(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): boolean;
 
@@ -2259,7 +2259,7 @@ declare namespace Immutable {
      * True if `predicate` returns true for any entry in the Iterable.
      */
     some(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): boolean;
 
@@ -2289,7 +2289,7 @@ declare namespace Immutable {
      */
     count(): number;
     count(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): number;
 
@@ -2300,7 +2300,7 @@ declare namespace Immutable {
      * Note: This is not a lazy operation.
      */
     countBy<G>(
-      grouper: (value?: V, key?: K, iter?: this) => G,
+      grouper: (value: V, key: K, iter: this) => G,
       context?: any
     ): Seq.Keyed<G, number>;
 
@@ -2311,7 +2311,7 @@ declare namespace Immutable {
      * Returns the first value for which the `predicate` returns true.
      */
     find(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any,
       notSetValue?: V
     ): V;
@@ -2322,7 +2322,7 @@ declare namespace Immutable {
      * Note: `predicate` will be called for each entry in reverse.
      */
     findLast(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any,
       notSetValue?: V
     ): V;
@@ -2331,7 +2331,7 @@ declare namespace Immutable {
      * Returns the first [key, value] entry for which the `predicate` returns true.
      */
     findEntry(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any,
       notSetValue?: V
     ): [K, V];
@@ -2343,7 +2343,7 @@ declare namespace Immutable {
      * Note: `predicate` will be called for each entry in reverse.
      */
     findLastEntry(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any,
       notSetValue?: V
     ): [K, V];
@@ -2352,7 +2352,7 @@ declare namespace Immutable {
      * Returns the key for which the `predicate` returns true.
      */
     findKey(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): K;
 
@@ -2362,7 +2362,7 @@ declare namespace Immutable {
      * Note: `predicate` will be called for each entry in reverse.
      */
     findLastKey(
-      predicate: (value?: V, key?: K, iter?: this) => boolean,
+      predicate: (value: V, key: K, iter: this) => boolean,
       context?: any
     ): K;
 
@@ -2401,7 +2401,7 @@ declare namespace Immutable {
      *
      */
     maxBy<C>(
-      comparatorValueMapper: (value?: V, key?: K, iter?: this) => C,
+      comparatorValueMapper: (value: V, key: K, iter: this) => C,
       comparator?: (valueA: C, valueB: C) => number
     ): V;
 
@@ -2430,7 +2430,7 @@ declare namespace Immutable {
      *
      */
     minBy<C>(
-      comparatorValueMapper: (value?: V, key?: K, iter?: this) => C,
+      comparatorValueMapper: (value: V, key: K, iter: this) => C,
       comparator?: (valueA: C, valueB: C) => number
     ): V;
 

inquirer/index.d.ts

@@ -30,7 +30,8 @@ declare namespace inquirer {
          * @param cb Callback being passed the user answers
          * @return
          */
-        prompt(questions: Questions, cb?: (answers: Answers) => any): ui.Prompt;
+        prompt(questions: Questions, cb: (answers: Answers) => any): ui.Prompt;
+        prompt(questions: Questions): Promise<Answers>;
         prompts: Prompts;
         Separator: objects.SeparatorStatic;
         ui: {

jasmine/index.d.ts

@@ -155,6 +155,7 @@ declare namespace jasmine {
         versionString(): string;
         nextSpecId(): number;
         addReporter(reporter: Reporter): void;
+        addReporter(reporter: CustomReporter): void;
         execute(): void;
         describe(description: string, specDefinitions: () => void): Suite;
         // ddescribe(description: string, specDefinitions: () => void): Suite; Not a part of jasmine. Angular team adds these
@@ -347,6 +348,45 @@ declare namespace jasmine {
         addReporter(reporter: Reporter): void;
     }
 
+    interface SuiteInfo {
+        totalSpecsDefined: number;
+    }
+
+    interface CustomReportExpectation {
+        matcherName: string;
+        message: string;
+        passed: boolean;
+        stack: string;
+    }
+
+    interface FailedExpectation extends CustomReportExpectation {
+        actual: string;
+        expected: string;
+    }
+
+    interface PassedExpectation extends CustomReportExpectation {
+
+    }
+
+    interface CustomReporterResult {
+      description: string,
+      failedExpectations?: FailedExpectation[],
+      fullName: string,
+      id: string;
+      passedExpectations?: PassedExpectation[],
+      pendingReason?: string;
+      status?: string;
+    }
+
+    interface CustomReporter {
+        jasmineStarted?(suiteInfo: SuiteInfo): void;
+        suiteStarted?(result: CustomReporterResult): void;
+        specStarted?(result: CustomReporterResult): void;
+        specDone?(result: CustomReporterResult): void;
+        suiteDone?(result: CustomReporterResult): void;
+        jasmineDone?(): any;
+    }
+
     interface Runner {
 
         new (env: Env): any;

jasmine/jasmine-tests.ts

@@ -902,6 +902,62 @@ describe("Custom matcher: 'toBeGoofy'", function () {
     });
 });
 
+// test based on http://jasmine.github.io/2.5/custom_reporter.html
+var myReporter: jasmine.CustomReporter = {
+    jasmineStarted: function (suiteInfo: jasmine.SuiteInfo ) {
+        console.log("Running suite with " + suiteInfo.totalSpecsDefined);
+    },
+
+    suiteStarted: function (result: jasmine.CustomReporterResult) {
+        console.log("Suite started: " + result.description + " whose full description is: " + result.fullName);
+    },
+
+    specStarted: function (result: jasmine.CustomReporterResult) {
+        console.log("Spec started: " + result.description + " whose full description is: " + result.fullName);
+    },
+
+    specDone: function (result: jasmine.CustomReporterResult) {
+        console.log("Spec: " + result.description + " was " + result.status);
+        for (var i = 0; i < result.failedExpectations.length; i++) {
+            console.log("Failure: " + result.failedExpectations[i].message);
+            console.log("Actual: " + result.failedExpectations[i].actual);
+            console.log("Expected: " + result.failedExpectations[i].expected);
+            console.log(result.failedExpectations[i].stack);
+        }
+        console.log(result.passedExpectations.length);
+    },
+      
+    suiteDone: function (result: jasmine.CustomReporterResult) {
+        console.log('Suite: ' + result.description + ' was ' + result.status);
+        for (var i = 0; i < result.failedExpectations.length; i++) {
+            console.log('AfterAll ' + result.failedExpectations[i].message);
+            console.log(result.failedExpectations[i].stack);
+        }
+    },
+
+    jasmineDone: function() {
+        console.log('Finished suite');
+    }
+};
+
+jasmine.getEnv().addReporter(myReporter);
+
+// test for custom reporter which return ES6 Promise in jasmineDone():
+var myShortReporter: jasmine.CustomReporter = {
+    jasmineDone: function() {
+        return new Promise<void>(function(resolve, reject) {  
+            setTimeout(() => resolve(), 10000);
+        });
+    }
+}
+
+var jasmineDoneResolved: Promise<void> = myShortReporter.jasmineDone();
+jasmineDoneResolved.then(() => {
+    console.log("[ShortReporter] : jasmineDone Resolved");
+});
+
+jasmine.getEnv().addReporter(myShortReporter);
+
 describe("Randomize Tests", function() {
 	it("should allow randomization of the order of tests", function() {
 		expect(function() {

jdenticon/index.d.ts

@@ -0,0 +1,26 @@
+// Type definitions for Jdenticon 1.3.2
+// Project: http://jdenticon.com/
+// Definitions by: Martin Thorsen Ranang <https://github.com/mtr/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export interface JdenticonConfig {
+    lightness?: {
+        color?: number[];
+        grayscale?: number[];
+    };
+    saturation?: number;
+}
+
+export var jdenticon_config: JdenticonConfig;
+
+export namespace jdenticon {
+    export function drawIcon(ctx: CanvasRenderingContext2D, hash: string, size: number): void;
+
+    export function toSvg(hash: string, size: number, padding?: number): string;
+
+    export function update(el: Element|string, hash?: string, padding?: number): void;
+
+    export let config: JdenticonConfig;
+
+    export const version: string;
+}

jdenticon/jdenticon-tests.ts

@@ -0,0 +1,11 @@
+import {jdenticon} from "jdenticon";
+
+function testJdenticon() {
+  if (typeof jdenticon.version !== 'string') {
+    throw '.version should be of string type.';
+  }
+
+  jdenticon.update('#jdenticon', 'd6d7705392bc7af633328bea8c4c6904', 8);
+}
+
+testJdenticon();

jdenticon/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es6",
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "baseUrl": "../",
+    "typeRoots": [
+      "../"
+    ],
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+    "index.d.ts",
+    "jdenticon-tests.ts"
+  ]
+}

jest/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Jest 15.1.1
+// Type definitions for Jest 16.0.0
 // Project: http://facebook.github.io/jest/
 // Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -26,23 +26,25 @@ interface NodeRequire {
 }
 
 declare namespace jest {
-    function addMatchers(matchers: jasmine.CustomMatcherFactories): void;
+    function addMatchers(matchers: jasmine.CustomMatcherFactories): typeof jest;
     /** Disables automatic mocking in the module loader. */
-    function autoMockOff(): void;
+    function autoMockOff(): typeof jest;
     /** Enables automatic mocking in the module loader. */
-    function autoMockOn(): void;
+    function autoMockOn(): typeof jest;
+    /** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
+    function clearAllMocks(): typeof jest;
     /** Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future. */
-    function clearAllTimers(): void;
+    function clearAllTimers(): typeof jest;
     /** Indicates that the module system should never return a mocked version of the specified module, including all of the specificied module's dependencies. */
-    function deepUnmock(moduleName: string): void;
+    function deepUnmock(moduleName: string): typeof jest;
     /** Disables automatic mocking in the module loader. */
-    function disableAutomock(): void;
+    function disableAutomock(): typeof jest;
     /** Mocks a module with an auto-mocked version when it is being required. */
-    function doMock(moduleName: string): void;
+    function doMock(moduleName: string): typeof jest;
     /** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
-    function dontMock(moduleName: string): void;
+    function dontMock(moduleName: string): typeof jest;
     /** Enables automatic mocking in the module loader. */
-    function enableAutomock(): void;
+    function enableAutomock(): typeof jest;
     /** Creates a mock function. Optionally takes a mock implementation. */
     function fn<T>(implementation?: Function): Mock<T>;
     /** Use the automatic mocking system to generate a mocked version of the given module. */
@@ -50,28 +52,30 @@ declare namespace jest {
     /** Returns whether the given function is a mock function. */
     function isMockFunction(fn: any): fn is Mock<any>;
     /** Mocks a module with an auto-mocked version when it is being required. */
-    function mock(moduleName: string, factory?: any, options?: MockOptions): void;
+    function mock(moduleName: string, factory?: any, options?: MockOptions): typeof jest;
     /** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
-    function resetModuleRegistry(): void;
+    function resetModuleRegistry(): typeof jest;
     /** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
-    function resetModules(): void;
+    function resetModules(): typeof jest;
     /** Exhausts tasks queued by setImmediate(). */
-    function runAllImmediates(): void;
+    function runAllImmediates(): typeof jest;
     /** Exhausts the micro-task queue (usually interfaced in node via process.nextTick). */
-    function runAllTicks(): void;
+    function runAllTicks(): typeof jest;
     /** Exhausts the macro-task queue (i.e., all tasks queued by setTimeout() and setInterval()). */
-    function runAllTimers(): void;
+    function runAllTimers(): typeof jest;
     /** Executes only the macro-tasks that are currently pending (i.e., only the tasks that have been queued by setTimeout() or setInterval() up to this point).
      * If any of the currently pending macro-tasks schedule new macro-tasks, those new tasks will not be executed by this call. */
-    function runOnlyPendingTimers(): void;
+    function runOnlyPendingTimers(): typeof jest;
+    /** Executes only the macro task queue (i.e. all tasks queued by setTimeout() or setInterval() and setImmediate()). */
+    function runTimersToTime(msToRun: number): typeof jest;
     /** Explicitly supplies the mock object that the module system should return for the specified module. */
-    function setMock<T>(moduleName: string, moduleExports: T): void;
+    function setMock<T>(moduleName: string, moduleExports: T): typeof jest;
     /** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
-    function unmock(moduleName: string): void;
+    function unmock(moduleName: string): typeof jest;
     /** Instructs Jest to use fake versions of the standard timer functions. */
-    function useFakeTimers(): void;
+    function useFakeTimers(): typeof jest;
     /** Instructs Jest to use the real versions of the standard timer functions. */
-    function useRealTimers(): void;
+    function useRealTimers(): typeof jest;
 
     interface MockOptions {
         virtual?: boolean;
@@ -98,6 +102,7 @@ declare namespace jest {
         (name: string, fn: ProvidesCallback): void;
         only: It;
         skip: It;
+        concurrent: It;
     }
 
     interface Describe {
@@ -124,6 +129,7 @@ declare namespace jest {
         toBeTruthy(): void;
         toBeUndefined(): void;
         toContain(expected: any): void;
+        toContainEqual(expected: any): void;
         toEqual(expected: any): void;
         toHaveBeenCalled(): boolean;
         toHaveBeenCalledTimes(expected: number): boolean;
@@ -132,6 +138,7 @@ declare namespace jest {
         toMatchSnapshot(): void;
         toThrow(): void;
         toThrowError(error?: string | Constructable | RegExp): void;
+        toThrowErrorMatchingSnapshot(): void;
     }
 
     interface Constructable {

jest/jest-tests.ts

@@ -208,6 +208,8 @@ describe('missing tests', function () {
        expect(getFruits()).toContain('Orange');
        mock.mockReturnValueOnce(['Apple', 'Plum']);
        expect(mock()).not.toContain('Orange');
+       const myBeverage: any = {delicious: true, sour: false}; 
+       expect(myBeverage).toContainEqual({delicious: true, sour: false});
        mock.mockReturnValue([]); //Deprecated: Use jest.fn(() => value) instead.
        mock.mockClear();
        let thisMock: jest.Mock<any> = jest.fn<any>().mockReturnThis();
@@ -215,8 +217,7 @@ describe('missing tests', function () {
    });
 
    it('creates snapshoter', function () {
-       jest.disableAutomock();
-       jest.mock('./render', () => jest.fn((): string => "{Link to: \"facebook\"}"), { virtual: true });
+       jest.disableAutomock().mock('./render', () => jest.fn((): string => "{Link to: \"facebook\"}"), { virtual: true });
        const render: () => string = require('./render');
        expect(render()).toMatch(/Link/);
        jest.enableAutomock();
@@ -225,7 +226,7 @@ describe('missing tests', function () {
    it('runs only pending timers', function () {
         jest.useRealTimers();
         setTimeout(() => expect(1).not.toEqual(0), 3000);
-        jest.runOnlyPendingTimers();
+        jest.runOnlyPendingTimers().runTimersToTime(300);
    });
 
    it('runs all timers', function () {
@@ -249,6 +250,12 @@ describe('toMatchSnapshot', function () {
     });
 });
 
+describe('toThrowErrorMatchingSnapshot', function () {
+   it('compares snapshots', function () {
+        expect(() => { throw new Error('descriptiton') }).toThrowErrorMatchingSnapshot();
+    });
+});
+
 function testInstances() {
     var mockFn = jest.fn<Function>();
     var a = new mockFn();

joi/index.d.ts

@@ -40,6 +40,10 @@ export interface ValidationOptions {
      * provides an external data set to be used in references
      */
     context?: Object;
+    /**
+     * when true, do not apply default values. Defaults to false.
+     */
+    noDefaults?: boolean;
 }
 
 export interface RenameOptions {
@@ -288,6 +292,16 @@ export interface AnySchema<T extends AnySchema<Schema>> {
      * @param schema - any object or joi schema to match. An undefined schema unsets that rule.
      */
     empty(schema?: any): T;
+    /**
+     * Overrides the default joi error with a custom error if the rule fails where:
+     * @param err - the override error.
+     *
+     * Note that the provided error will be returned as-is, unmodified and undecorated
+     * with any of the normal joi error properties. If validation fails and another
+     * error is found before the error override, that error will be returned and the
+     * override will be ignored (unless the abortEarly option has been set to false).
+     */
+    error?(err: Error): T;
 }
 
 export interface BooleanSchema extends AnySchema<BooleanSchema> {
@@ -828,10 +842,18 @@ export declare function lazy(cb: () => Schema): Schema;
 /**
  * Validates a value using the given schema and options.
  */
-export declare function validate<T>(value: T, schema: Schema, callback: (err: ValidationError, value: T) => void): void;
-export declare function validate<T>(value: T, schema: Object, callback: (err: ValidationError, value: T) => void): void;
-export declare function validate<T>(value: T, schema: Object, options?: ValidationOptions, callback?: (err: ValidationError, value: T) => void): ValidationResult<T>;
+export function validate<T>(value: T): ValidationResult<T>;
+export function validate<T, R>(value: T, callback: (err: ValidationError, value: T) => R): R;
 
+export function validate<T>(value: T, schema: Schema): ValidationResult<T>;
+export function validate<T>(value: T, schema: Object): ValidationResult<T>;
+export function validate<T, R>(value: T, schema: Schema, callback: (err: ValidationError, value: T) => R): R;
+export function validate<T, R>(value: T, schema: Object, callback: (err: ValidationError, value: T) => R): R;
+
+export function validate<T>(value: T, schema: Schema, options: ValidationOptions): ValidationResult<T>;
+export function validate<T>(value: T, schema: Object, options: ValidationOptions): ValidationResult<T>;
+export function validate<T, R>(value: T, schema: Schema, options: ValidationOptions, callback: (err: ValidationError, value: T) => R): R;
+export function validate<T, R>(value: T, schema: Object, options: ValidationOptions, callback: (err: ValidationError, value: T) => R): R;
 /**
  * Converts literal schema definition to joi schema object (or returns the same back if already a joi schema object).
  */
@@ -879,3 +901,118 @@ export function reach(schema: Schema, path: string): Schema;
  * Creates a new Joi instance customized with the extension(s) you provide included.
  */
 export function extend(extention: Extension): any;
+
+/**
+ * Whitelists a value
+ */
+export function allow(value: any, ...values: any[]): Schema;
+export function allow(values: any[]): Schema;
+
+/**
+ * Adds the provided values into the allowed whitelist and marks them as the only valid values allowed.
+ */
+export function valid(value: any, ...values: any[]): Schema;
+export function valid(values: any[]): Schema;
+export function only(value: any, ...values : any[]): Schema;
+export function only(values: any[]): Schema;
+export function equal(value: any, ...values : any[]): Schema;
+export function equal(values: any[]): Schema;
+
+/**
+ * Blacklists a value
+ */
+export function invalid(value: any, ...values: any[]): Schema;
+export function invalid(values: any[]): Schema;
+export function disallow(value: any, ...values : any[]): Schema;
+export function disallow(values: any[]): Schema;
+export function not(value: any, ...values : any[]): Schema;
+export function not(values: any[]): Schema;
+
+/**
+ * Marks a key as required which will not allow undefined as value. All keys are optional by default.
+ */
+export function required(): Schema;
+
+/**
+ * Marks a key as optional which will allow undefined as values. Used to annotate the schema for readability as all keys are optional by default.
+ */
+export function optional(): Schema;
+
+/**
+ * Marks a key as forbidden which will not allow any value except undefined. Used to explicitly forbid keys.
+ */
+export function forbidden(): Schema;
+
+/**
+ * Marks a key to be removed from a resulting object or array after validation. Used to sanitize output.
+ */
+export function strip(): Schema;
+
+/**
+ * Annotates the key
+ */
+export function description(desc: string): Schema;
+
+/**
+ * Annotates the key
+ */
+export function notes(notes: string): Schema;
+export function notes(notes: string[]): Schema;
+
+/**
+ * Annotates the key
+ */
+export function tags(notes: string): Schema;
+export function tags(notes: string[]): Schema;
+
+/**
+ * Attaches metadata to the key.
+ */
+export function meta(meta: Object): Schema;
+
+/**
+ * Annotates the key with an example value, must be valid.
+ */
+export function example(value: any): Schema;
+
+/**
+ * Annotates the key with an unit name.
+ */
+export function unit(name: string): Schema;
+
+/**
+ * Overrides the global validate() options for the current key and any sub-key.
+ */
+export function options(options: ValidationOptions): Schema;
+
+/**
+ * Sets the options.convert options to false which prevent type casting for the current key and any child keys.
+ */
+export function strict(isStrict?: boolean): Schema;
+
+/**
+ * Returns a new type that is the result of adding the rules of one type to another.
+ */
+export function concat<T>(schema: T): T;
+
+/**
+ * Converts the type into an alternatives type where the conditions are merged into the type definition where:
+ */
+export function when<U>(ref: string, options: WhenOptions<U>): AlternativesSchema;
+export function when<U>(ref: Reference, options: WhenOptions<U>): AlternativesSchema;
+
+/**
+ * Overrides the key name in error messages.
+ */
+export function label(name: string): Schema;
+
+/**
+ * Outputs the original untouched value instead of the casted value.
+ */
+export function raw(isRaw?: boolean): Schema;
+
+/**
+ * Considers anything that matches the schema to be empty (undefined).
+ * @param schema - any object or joi schema to match. An undefined schema unsets that rule.
+ */
+export function empty(schema?: any) : Schema;

joi/joi-tests.ts

@@ -58,6 +58,7 @@ validOpts = {stripUnknown: bool};
 validOpts = {language: bool};
 validOpts = {presence: str};
 validOpts = {context: obj};
+validOpts = {noDefaults: bool};
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
@@ -222,6 +223,8 @@ namespace common {
 	anySchema = anySchema.empty();
 	anySchema = anySchema.empty(str);
 	anySchema = anySchema.empty(anySchema);
+	
+	anySchema = anySchema.error(err);
 }
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
@@ -757,30 +760,57 @@ schema = Joi.lazy(() => schema)
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
-Joi.validate(value, obj);
-Joi.validate(value, schema);
-Joi.validate(value, schema, validOpts);
-Joi.validate(value, schema, validOpts, (err, value) => {
+namespace validate_tests {
+    {
+        Joi.validate(value, obj);
+        Joi.validate(value, schema);
+        Joi.validate(value, schema, validOpts);
+        Joi.validate(value, schema, validOpts, (err, value) => {
 	x = value;
 	str = err.message;
 	str = err.details[0].path;
 	str = err.details[0].message;
 	str = err.details[0].type;
-});
-Joi.validate(value, schema, (err, value) => {
+        });
+        Joi.validate(value, schema, (err, value) => {
 	x = value;
 	str = err.message;
 	str = err.details[0].path;
 	str = err.details[0].message;
 	str = err.details[0].type;
-});
-// variant
-Joi.validate(num, schema, validOpts, (err, value) => {
+        });
+        // variant
+        Joi.validate(num, schema, validOpts, (err, value) => {
 	num = value;
-});
+        });
+
+        // plain opts
+        Joi.validate(value, {});
+    }
+
+    {
+        let value = { username: 'example', password: 'example' };
+        let schema = Joi.object().keys({
+            username: Joi.string().max(255).required(),
+            password: Joi.string().regex(/^[a-zA-Z0-9]{3,255}$/).required(),
+        });
+        let returnValue: Joi.ValidationResult<typeof value>;
+
+        returnValue = Joi.validate(value);
+        value = Joi.validate(value, (err, value) => value);
+
+        returnValue = Joi.validate(value, schema);
+        returnValue = Joi.validate(value, obj);
+        value = Joi.validate(value, obj, (err, value) => value);
+        value = Joi.validate(value, schema, (err, value) => value);
+
+        returnValue = Joi.validate(value, schema, validOpts);
+        returnValue = Joi.validate(value, obj, validOpts);
+        value = Joi.validate(value, obj, validOpts, (err, value) => value);
+        value = Joi.validate(value, schema, validOpts, (err, value) => value);
+    }
+}
 
-// plain opts
-Joi.validate(value, {});
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
@@ -802,3 +832,56 @@ Joi.isRef(ref);
 schema = Joi.reach(schema, '');
 
 const Joi2 = Joi.extend({ name: '', base: schema });
+
+// --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+
+schema = Joi.allow(x, x);
+schema = Joi.allow([x, x, x]);
+schema = Joi.valid(x);
+schema = Joi.valid(x, x);
+schema = Joi.valid([x, x, x]);
+schema = Joi.only(x);
+schema = Joi.only(x, x);
+schema = Joi.only([x, x, x]);
+schema = Joi.equal(x);
+schema = Joi.equal(x, x);
+schema = Joi.equal([x, x, x]);
+schema = Joi.invalid(x);
+schema = Joi.invalid(x, x);
+schema = Joi.invalid([x, x, x]);
+schema = Joi.disallow(x);
+schema = Joi.disallow(x, x);
+schema = Joi.disallow([x, x, x]);
+schema = Joi.not(x);
+schema = Joi.not(x, x);
+schema = Joi.not([x, x, x]);
+
+schema = Joi.required();
+schema = Joi.optional();
+schema = Joi.forbidden();
+schema = Joi.strip();
+
+schema = Joi.description(str);
+schema = Joi.notes(str);
+schema = Joi.notes(strArr);
+schema = Joi.tags(str);
+schema = Joi.tags(strArr);
+
+schema = Joi.meta(obj);
+schema = Joi.example(obj);
+schema = Joi.unit(str);
+
+schema = Joi.options(validOpts);
+schema = Joi.strict();
+schema = Joi.strict(bool);
+schema = Joi.concat(x);
+
+schema = Joi.when(str, whenOpts);
+schema = Joi.when(ref, whenOpts);
+
+schema = Joi.label(str);
+schema = Joi.raw();
+schema = Joi.raw(bool);
+schema = Joi.empty();
+schema = Joi.empty(str);
+schema = Joi.empty(anySchema);

jointjs/index.d.ts

@@ -1,135 +1,559 @@
-// Type definitions for Joint JS 0.9.3
+// Type definitions for Joint JS 1.0.1
 // Project: http://www.jointjs.com/
-// Definitions by: Aidan Reel <http://github.com/areel>, David Durman <http://github.com/DavidDurman>, Ewout Van Gossum <https://github.com/DenEwout>
+// Definitions by: Aidan Reel <http://github.com/areel>, David Durman <http://github.com/DavidDurman>, Ewout Van Gossum <https://github.com/DenEwout>, Federico Caselli <https://github.com/CaselIT>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// typings: https://github.com/CaselIT/typings-jointjs
 
 /// <reference types="backbone" />
 
+
 declare namespace joint {
+    export var g: any;
+    export var V: any;
 
     namespace dia {
-
-        interface IElementSize {
+        interface Size {
             width: number;
             height: number;
         }
 
+        interface Point {
+            x: number;
+            y: number;
+        }
+
+        interface BBox extends Point, Size { }
+
+        interface TranslateOptions {
+            restrictedArea?: BBox;
+            transition?: TransitionOptions;
+        }
+
+        interface TransitionOptions {
+            delay?: number;
+            duration?: number;
+            timingFunction?: (t: number) => number;
+            valueFunction?: (a: any, b: any) => (t: number) => any;
+        }
+
+        interface DfsBfsOptions {
+            inbound?: boolean;
+            outbound?: boolean;
+            deep?: boolean;
+        }
+
+        interface ExploreOptions {
+            breadthFirst?: boolean;
+            deep?: boolean;
+        }
+
         class Graph extends Backbone.Model {
-            addCell(cell:Cell) : void;
-            addCells(cells:Cell[]) : void;
-            initialize() : void;
-            fromJSON(json:any) : void;
-            toJSON() : Object;
-            clear() : void;
-            getConnectedLinks(cell:Cell, opt?:any):Link[];
-            disconnectLinks(cell:Cell) : void;
-            removeLinks(cell:Cell) : void;
-            findModelsFromPoint(point:{x : number; y: number}):Element[];
+            constructor(attributes?: any, options?: { cellNamespace: any });
+            addCell(cell: Cell | Cell[]): this;
+            addCells(cells: Cell[]): this;
+            resetCells(cells: Cell[], options?: any): this;
+            getCell(id: string): Cell;
+            getElements(): Element[];
+            getLinks(): Link[];
+            getCells(): Cell[];
+            getFirstCell(): Cell;
+            getLastCell(): Cell;
+            getConnectedLinks(element: Cell, options?: { inbound?: boolean, outbound?: boolean, deep?: boolean }): Link[];
+            disconnectLinks(cell: Cell, options?: any): void;
+            removeLinks(cell: Cell, options?: any): void;
+            translate(tx: number, ty?: number, options?: TranslateOptions): void;
+            cloneCells(cells: Cell[]): { [id: string]: Cell };
+            getSubgraph(cells: Cell[], options?: { deep?: boolean }): Cell[];
+            cloneSubgraph(cells: Cell[], options?: { deep?: boolean }): { [id: string]: Cell };
+            dfs(element: Element, iteratee: (element: Element, distance: number) => boolean, options?: DfsBfsOptions, visited?: Object, distance?: number): void;
+            bfs(element: Element, iteratee: (element: Element, distance: number) => boolean, options?: DfsBfsOptions): void;
+            search(element: Element, iteratee: (element: Element, distance: number) => boolean, options?: { breadthFirst?: boolean }): void;
+            getSuccessors(element: Element, options?: ExploreOptions): Element[];
+            getPredecessors(element: Element, options?: ExploreOptions): Element[];
+            isSuccessor(elementA: Element, elementB: Element): boolean;
+            isPredecessor(elementA: Element, elementB: Element): boolean;
+            isSource(element: Element): boolean;
+            isSink(element: Element): boolean;
+            getSources(): Element[];
+            getSinks(): Element[];
+            getNeighbors(element: Element, options?: DfsBfsOptions): Element[];
+            isNeighbor(elementA: Element, elementB: Element, options?: { inbound?: boolean, outbound?: boolean; }): boolean;
+            getCommonAncestor(...cells: Cell[]): Element;
+            toJSON(): any;
+            fromJSON(json: any, options?: any): this;
+            clear(options?: any): this;
+            findModelsFromPoint(rect: BBox): Element[];
+            findModelsUnderElement(element: Element, options?: { searchBy?: 'bbox' | 'center' | 'origin' | 'corner' | 'topRight' | 'bottomLeft' }): Element[];
+            getBBox(elements: Element[], options?: any): BBox;
+            toGraphLib(): any; // graphlib graph object
+            findModelsInArea(rect: BBox, options?: any): BBox | boolean;
+            getCellsBBox(cells: Cell[], options?: any): BBox;
+            getInboundEdges(node: string): Object;
+            getOutboundEdges(node: string): Object;
+            hasActiveBatch(name?: string): number | boolean;
+            maxZIndex(): number;
+            removeCells(cells: Cell[], options?: any): this;
+            resize(width: number, height: number, options?: number): this;
+            resizeCells(width: number, height: number, cells: Cell[], options?: number): this;
+            set(key: Object | string, value: any, options?: any): this;
+            startBatch(name: string, data?: Object): any;
+            stopBatch(name: string, data?: Object): any;
         }
 
         class Cell extends Backbone.Model {
-            toJSON() : Object;
-            remove(options?:any) : void;
-            toFront() : void;
-            toBack() : void;
-            embed(cell:Cell) : void;
-            unembed(cell:Cell) : void;
-            getEmbeddedCells():Cell[];
-            clone(opt?:any):Backbone.Model;      // @todo: return can either be Cell or Cell[].
-            attr(attrs:any):Cell;
+            id: string;
+            toJSON(): any;
+            remove(options?: { disconnectLinks?: boolean }): this;
+            toFront(options?: { deep?: boolean }): this;
+            toBack(options?: { deep?: boolean }): this;
+            getAncestors(): Cell[];
+            isEmbeddedIn(element: Element, options?: { deep: boolean }): boolean;
+            prop(key: string): any;
+            prop(object: any): this;
+            prop(key: string, value: any, options?: any): this;
+            removeProp(path: string, options?: any): this;
+            attr(key: string): any;
+            attr(object: SVGAttributes): this;
+            attr(key: string, value: any): this;
+            clone(): Cell;
+            clone(opt: { deep?: boolean }): Cell | Cell[];
+            removeAttr(path: string | string[], options?: any): this;
+            transition(path: string, value?: any, options?: TransitionOptions, delim?: string): number;
+            getTransitions(): string[];
+            stopTransitions(path?: string, delim?: string): this;
+            addTo(graph: Graph, options?: any): this;
+            isLink(): boolean;
+            embed(cell: Cell, options?: any): this;
+            findView(paper: Paper): CellView;
+            getEmbeddedCells(options?: any): Cell[];
+            initialize(options?: any): void;
+            isElement(): boolean;
+            isEmbedded(): boolean;
+            processPorts(): void;
+            startBatch(name: string, options?: any): this;
+            stopBatch(name: string, options?: any): this;
+            unembed(cell: Cell, options?: any): this;
         }
 
+        type Padding = number | {
+            top?: number;
+            right?: number;
+            bottom?: number;
+            left?: number
+        };
+
         class Element extends Cell {
-            position(x:number, y:number):Element;
-            position(): {x:number, y:number}; 
-            translate(tx:number, ty?:number):Element;
-            resize(width:number, height:number):Element;
-            rotate(angle:number, options : {absolute : boolean; origin: {x:number;y:number}}):Element;
-            remove(): void;
+            translate(tx: number, ty?: number, options?: TranslateOptions): this;
+            position(options?: { parentRelative: boolean }): Point;
+            position(x: number, y: number, options?: { parentRelative?: boolean }): this;
+            resize(width: number, height: number, options?: { direction?: 'left' | 'right' | 'top' | 'bottom' | 'top-right' | 'top-left' | 'bottom-left' | 'bottom-right' }): this;
+            rotate(deg: number, absolute?: boolean, origin?: Point): this;
+            embed(cell: Cell): this;
+            unembed(cell: Cell): this;
+            getEmbeddedCells(options?: ExploreOptions): Cell[];
+            fitEmbeds(options?: { deep?: boolean, padding?: Padding }): this;
+            getBBox(options?: any): BBox;
+            findView(paper: Paper): ElementView;
+            isElement(): boolean;
+            scale(scaleX: number, scaleY: number, origin?: Point, options?: any): this;
         }
 
-        interface IDefaults {
-            type: string;
+        interface CSSSelector {
+            [key: string]: string | number | Object; // Object added to support special attributes like filter http://jointjs.com/api#SpecialAttributes:filter
+        }
+
+        interface SVGAttributes {
+            [selector: string]: CSSSelector;
+        }
+
+        interface CellAttributes {
+            [key: string]: any;
+        }
+
+        interface TextAttrs extends SVGAttributes {
+            text?: {
+                [key: string]: string | number;
+                text?: string;
+            };
+        }
+
+        interface Label {
+            position: number;
+            attrs?: TextAttrs;
+        }
+        interface LinkAttributes extends CellAttributes {
+            source?: Point | { id: string, selector?: string, port?: string };
+            target?: Point | { id: string, selector?: string, port?: string };
+            labels?: Label[];
+            vertices?: Point[];
+            smooth?: boolean;
+            attrs?: TextAttrs;
         }
 
         class Link extends Cell {
-            defaults():IDefaults;
-            disconnect():Link;
-            label(idx?:number, value?:any):any;   // @todo: returns either a label under idx or Link if both idx and value were passed
-            remove(): void;
+            markup: string;
+            labelMarkup: string;
+            toolMakup: string;
+            vertexMarkup: string;
+            arrowHeadMarkup: string;
+
+            constructor(attributes?: LinkAttributes, options?: Object);
+            disconnect(): this;
+            label(index?: number): any;
+            label(index: number, value: Label): this;
+            reparent(options?: any): Element;
+            findView(paper: Paper): LinkView;
+            getSourceElement(): Element;
+            getTargetElement(): Element;
+            hasLoop(options?: { deep?: boolean }): boolean;
+            applyToPoints(fn: Function, options?: any): this;
+            getRelationshipAncestor(): Element;
+            isLink(): boolean;
+            isRelationshipEmbeddedIn(element: Element): boolean;
+            scale(sx: number, sy: number, origin: Point, optionts?: any): this;
+            translate(tx: number, ty: number, options?: any): this;
         }
 
-        interface IOptions {
+        interface ManhattanRouterArgs {
+            excludeTypes?: string[];
+            excludeEnds?: 'source' | 'target';
+            startDirections?: ['left' | 'right' | 'top' | 'bottom'];
+            endDirections?: ['left' | 'right' | 'top' | 'bottom'];
+        }
+
+        interface PaperOptions extends Backbone.ViewOptions<Graph> {
+            el?: string | JQuery | HTMLElement;
             width?: number;
             height?: number;
+            origin?: Point;
             gridSize?: number;
             perpendicularLinks?: boolean;
-            elementView?: ElementView;
-            linkView?: LinkView;
+            elementView?: (element: Element) => ElementView | ElementView;
+            linkView?: (link: Link) => LinkView | LinkView;
+            defaultLink?: ((cellView: CellView, magnet: SVGElement) => Link) | Link;
+            defaultRouter?: ((vertices: Point[], args: Object, linkView: LinkView) => Point[]) | { name: string, args?: ManhattanRouterArgs };
+            defaultConnector?: ((sourcePoint: Point, targetPoint: Point, vertices: Point[], args: Object, linkView: LinkView) => string) | { name: string, args?: { radius?: number } };
+            interactive?: ((cellView: CellView, event: string) => boolean) | boolean | { vertexAdd?: boolean, vertexMove?: boolean, vertexRemove?: boolean, arrowheadMove?: boolean };
+            validateMagnet?: (cellView: CellView, magnet: SVGElement) => boolean;
+            validateConnection?: (cellViewS: CellView, magnetS: SVGElement, cellViewT: CellView, magnetT: SVGElement, end: 'source' | 'target', linkView: LinkView) => boolean;
+            linkConnectionPoint?: (linkView: LinkView, view: ElementView, magnet: SVGElement, reference: Point) => Point;
+            snapLinks?: boolean | { radius: number };
+            linkPinning?: boolean;
+            markAvailable?: boolean;
+            async?: boolean | { batchZise: number };
+            embeddingMode?: boolean;
+            validateEmbedding?: (childView: ElementView, parentView: ElementView) => boolean;
+            restrictTranslate?: ((elementView: ElementView) => BBox) | boolean;
+            guard?: (evt: Event, view: CellView) => boolean;
+            multiLinks?: boolean;
+            cellViewNamespace?: Object;
+            /** useful undocumented option */
+            clickThreshold?: number;
         }
 
-        class Paper extends Backbone.View<Backbone.Model> {
-            options:IOptions;
-
-            setDimensions(width:number, height:number) : void;
-            scale(sx:number, sy?:number, ox?:number, oy?:number):Paper;
-            rotate(deg:number, ox?:number, oy?:number):Paper;      // @todo not released yet though it's in the source code already
-            findView(el:any):CellView;
-            findViewByModel(modelOrId:any):CellView;
-            findViewsFromPoint(p:{ x: number; y: number; }):CellView[];
-            findViewsInArea(r:{ x: number; y: number; width: number; height: number; }):CellView[];
-            fitToContent(opt?:any): void;
+        interface ScaleContentOptions {
+            padding?: number;
+            preserveAspectRatio?: boolean;
+            minScale?: number;
+            minScaleX?: number;
+            minScaleY?: number;
+            maxScale?: number;
+            maxScaleX?: number;
+            maxScaleY?: number;
+            scaleGrid?: number;
+            fittingBBox?: BBox;
         }
 
-        class ElementView extends CellView {
-            scale(sx:number, sy:number) : void;
+        interface FitToContentOptions {
+            gridWidth?: number;
+            gridHeight?: number;
+            padding?: Padding;
+            allowNewOrigin?: 'negative' | 'positive' | 'any';
+            minWidth?: number;
+            minHeight?: number;
+            maxWidth?: number;
+            maxHeight?: number;
         }
 
-        class CellView extends Backbone.View<Cell> {
-            getBBox():{ x: number; y: number; width: number; height: number; };
-            highlight(el?:any): void;
-            unhighlight(el?:any): void;
-            findMagnet(el:any): void;
-            getSelector(el:any): void;
+        class Paper extends Backbone.View<Graph> {
+            constructor(options?: PaperOptions);
+            options: PaperOptions;
+            svg: SVGElement;
+            viewport: SVGGElement;
+            defs: SVGDefsElement;
+            setDimensions(width: number, height: number): void;
+            setOrigin(x: number, y: number): void;
+            scale(sx: number, sy?: number, ox?: number, oy?: number): this;
+            findView(element: any): CellView;
+            findViewByModel(model: Cell | string): CellView;
+            findViewsFromPoint(point: Point): ElementView[];
+            findViewsInArea(rect: BBox, options?: { strict?: boolean }): CellView[];
+            fitToContent(options?: FitToContentOptions): void;
+            scaleContentToFit(options?: ScaleContentOptions): void;
+            getContentBBox(): BBox;
+            clientToLocalPoint(p: Point): Point;
 
-            pointerdblclick(evt:any, x:number, y:number):void;
-            pointerclick(evt:any, x:number, y:number):void;
-            pointerdown(evt:any, x:number, y:number):void;
-            pointermove(evt:any, x:number, y:number):void;
-            pointerup(evt:any, x:number, y:number):void;
+            rotate(deg: number, ox?: number, oy?: number): Paper;      // @todo not released yet though it's in the source code already
+
+            afterRenderViews(): void;
+            asyncRenderViews(cells: Cell[], options?: any): void;
+            beforeRenderViews(cells: Cell[]): Cell[];
+            cellMouseout(evt: Event): void;
+            cellMouseover(evt: Event): void;
+            clearGrid(): this;
+            contextmenu(evt: Event): void;
+            createViewForModel(cell: Cell): CellView;
+            drawGrid(options?: any): this;
+            fitToContent(gridWidth?: number, gridHeight?: number, padding?: number, options?: any): void;
+            getArea(): BBox;
+            getDefaultLink(cellView: CellView, magnet: HTMLElement): Link;
+            getModelById(id: string): Cell;
+            getRestrictedArea(): BBox;
+            guard(evt: Event, view: CellView): boolean;
+            linkAllowed(linkViewOrModel: LinkView | Link): boolean;
+            mouseclick(evt: Event): void;
+            mousedblclick(evt: Event): void;
+            mousewheel(evt: Event): void;
+            onCellAdded(cell: Cell, graph: Graph, options: Object): void;
+            onCellHighlight(cellView: CellView, magnetEl: HTMLElement, options?: any): void;
+            onCellUnhighlight(cellView: CellView, magnetEl: HTMLElement, options?: any): void;
+            onRemove(): void;
+            pointerdown(evt: Event): void;
+            pointermove(evt: Event): void;
+            pointerup(evt: Event): void;
+            remove(): this;
+            removeView(cell: Cell): CellView;
+            removeViews(): void;
+            renderView(cell: Cell): CellView;
+            resetViews(cellsCollection: Cell[], options: any): void;
+            resolveHighlighter(options?: any): boolean | Object;
+            setGridSize(gridSize: number): this;
+            setInteractivity(value: any): void;
+            snapToGrid(p: Point): Point;
+            sortViews(): void;
         }
 
-        class LinkView extends CellView {
-            getConnectionLength():number;
-            getPointAtLength(length:number):{ x: number; y: number; };
+
+        interface GradientOptions {
+            type: 'linearGradient' | 'radialGradient';
+            stops: Array<{
+                offset: string;
+                color: string;
+                opacity?: number;
+            }>;
+        }
+        class CellViewGeneric<T extends Backbone.Model> extends Backbone.View<T> {
+            getBBox(options?: { useModelGeometry?: boolean }): BBox;
+            highlight(el?: any, options?: any): this;
+            unhighlight(el?: any, options?: any): this;
+            applyFilter(selector: string | HTMLElement, filter: Object): void;
+            applyGradient(selector: string | HTMLElement, attr: 'fill' | 'stroke', gradient: GradientOptions): void;
+            can(feature: string): boolean;
+            findBySelector(selector: string): JQuery;
+            findMagnet(el: any): HTMLElement;
+            getSelector(el: HTMLElement, prevSelector: string): string;
+            getStrokeBBox(el: any): BBox; // string|HTMLElement|Vectorizer
+            mouseout(evt: Event): void;
+            mouseover(evt: Event): void;
+            mousewheel(evt: Event, x: number, y: number, delta: number): void
+            notify(eventName: string): void;
+            onChangeAttrs(cell: Cell, attrs: Backbone.ViewOptions<T>, options?: any): this;
+            onSetTheme(oldTheme: string, newTheme: string): void;
+            pointerclick(evt: Event, x: number, y: number): void;
+            pointerdblclick(evt: Event, x: number, y: number): void;
+            pointerdown(evt: Event, x: number, y: number): void;
+            pointermove(evt: Event, x: number, y: number): void;
+            pointerup(evt: Event, x: number, y: number): void;
+            remove(): this;
+            setInteractivity(value: any): void;
+            setTheme(theme: string, options?: any): this;
         }
 
+        class CellView extends CellViewGeneric<Cell> { }
+
+        interface ElementViewAttributes {
+            style?: string;
+            text?: string;
+            html?: string;
+            "ref-x"?: string | number;
+            "ref-y"?: string | number;
+            "ref-dx"?: number;
+            "ref-dy"?: number;
+            "ref-width"?: string | number;
+            "ref-height"?: string | number;
+            ref?: string;
+            "x-alignment"?: 'middle' | 'right' | number;
+            "y-alignment"?: 'middle' | 'bottom' | number;
+            port?: string;
+        }
+        class ElementView extends CellViewGeneric<Element> {
+            scale(sx: number, sy: number): void; // @todo Documented in source but not released
+            finalizeEmbedding(options?: any): void;
+            getBBox(options?: any): BBox;
+            pointerdown(evt: Event, x: number, y: number): void;
+            pointermove(evt: Event, x: number, y: number): void;
+            pointerup(evt: Event, x: number, y: number): void;
+            positionRelative(vel: any, bbox: BBox, attributes: ElementViewAttributes, nodesBySelector?: Object): void; // Vectorizer
+            prepareEmbedding(options?: any): void;
+            processEmbedding(options?: any): void;
+            render(): this;
+            renderMarkup(): void;
+            resize(): void;
+            rotate(): void;
+            translate(model: Backbone.Model, changes?: any, options?: any): void;
+            update(cell: Cell, renderingOnlyAttrs?: Object): void;
+        }
+
+        class LinkView extends CellViewGeneric<Link> {
+            options: {
+                shortLinkLength?: number,
+                doubleLinkTools?: boolean,
+                longLinkLength?: number,
+                linkToolsOffset?: number,
+                doubleLinkToolsOffset?: number,
+                sampleInterval: number
+            };
+            getConnectionLength(): number;
+            sendToken(token: SVGElement, duration?: number, callback?: () => void): void;
+            addVertex(vertex: Point): number;
+            getPointAtLength(length: number): Point; // Marked as public api in source but not in the documents
+            createWatcher(endType: { id: string }): Function;
+            findRoute(oldVertices: Point[]): Point[];
+            getConnectionPoint(end: 'source' | 'target', selectorOrPoint: Element | Point, referenceSelectorOrPoint: Element | Point): Point;
+            getPathData(vertices: Point[]): any;
+            onEndModelChange(endType: 'source' | 'target', endModel?: Element, opt?: any): void;
+            onLabelsChange(): void;
+            onSourceChange(cell: Cell, sourceEnd: { id: string }, options: any): void;
+            onTargetChange(cell: Cell, targetEnd: { id: string }, options: any): void;
+            onToolsChange(): void;
+            onVerticesChange(cell: Cell, changed: any, options: any): void;
+            pointerdown(evt: Event, x: number, y: number): void;
+            pointermove(evt: Event, x: number, y: number): void;
+            pointerup(evt: Event, x: number, y: number): void;
+            removeVertex(idx: number): this;
+            render(): this;
+            renderArrowheadMarkers(): this;
+            renderLabels(): this;
+            renderTools(): this;
+            renderVertexMarkers(): this;
+            startArrowheadMove(end: 'source' | 'target', options?: any): void;
+            startListening(): void;
+            update(model: any, attributes: any, options?: any): this;
+            updateArrowheadMarkers(): this;
+            updateAttributes(): void;
+            updateConnection(options?: any): void;
+            updateLabelPositions(): this;
+            updateToolsPosition(): this;
+        }
     }
 
-    namespace ui {}
+    namespace ui { }
 
     namespace shapes {
+        interface GenericAttributes<T> extends dia.CellAttributes {
+            position?: dia.Point;
+            size?: dia.Size;
+            angle?: number;
+            attrs?: T;
+        }
+        interface ShapeAttrs extends dia.CSSSelector {
+            fill?: string;
+            stroke?: string;
+            r?: string | number;
+            rx?: string | number;
+            ry?: string | number;
+            cx?: string | number;
+            cy?: string | number;
+            height?: string | number;
+            width?: string | number;
+        }
         namespace basic {
             class Generic extends dia.Element {
+                constructor(attributes?: GenericAttributes<dia.SVGAttributes>, options?: Object)
+            }
+            interface RectAttrs extends dia.TextAttrs {
+                rect?: ShapeAttrs;
             }
             class Rect extends Generic {
+                constructor(attributes?: GenericAttributes<RectAttrs>, options?: Object)
             }
             class Text extends Generic {
+                constructor(attributes?: GenericAttributes<dia.TextAttrs>, options?: Object)
+            }
+            interface CircleAttrs extends dia.TextAttrs {
+                circle?: ShapeAttrs;
             }
             class Circle extends Generic {
+                constructor(attributes?: GenericAttributes<CircleAttrs>, options?: Object)
+            }
+            interface EllipseAttrs extends dia.TextAttrs {
+                ellipse?: ShapeAttrs;
+            }
+            class Ellipse extends Generic {
+                constructor(attributes?: GenericAttributes<EllipseAttrs>, options?: Object)
             }
             class Image extends Generic {
             }
+            class Path extends Generic {
+            }
+            class Polygon extends Generic {
+            }
+            class Polyline extends Generic {
+            }
         }
     }
 
     namespace util {
-        function uuid():string;
-        function guid(obj:any):string;
-        function mixin(objects:any[]):any;
-        function supplement(objects:any[]):any;
-        function deepMixin(objects:any[]):any;
-        function deepSupplement(objects:any[], defaultIndicator?:any):any;
+
+        namespace format {
+            export function number(specifier: string, value: number): string;
+        }
+
+        export function uuid(): string;
+        export function guid(obj?: Object): string;
+        export function nextFrame(callback: () => void, context?: Object): number;
+        export function cancelFrame(requestId: number): void;
+        export function flattenObject(object: Object, delim: string, stop: (node: any) => boolean): any;
+        export function getByPath(object: Object, path: string, delim: string): any;
+        export function setByPath(object: Object, path: string, value: Object, delim: string): any;
+        export function unsetByPath(object: Object, path: string, delim: string): any;
+        export function breakText(text: string, size: dia.Size, attrs?: dia.SVGAttributes, options?: { svgDocument?: SVGElement }): string;
+        export function normalizeSides(box: number | { x?: number, y?: number, height?: number, width?: number }): dia.BBox;
+        export function getElementBBox(el: Element): dia.BBox;
+        export function setAttributesBySelector(el: Element, attrs: dia.SVGAttributes): void;
+        export function sortElements(elements: Element[] | string | JQuery, comparator: (a: Element, b: Element) => number): Element[];
+        export function shapePerimeterConnectionPoint(linkView: dia.LinkView, view: dia.ElementView, magnet: SVGElement, ref: dia.Point): dia.Point;
+        export function imageToDataUri(url: string, callback: (err: Error, dataUri: string) => void): void;
+
+        // Not documented but used in examples
+        /** @deprecated use lodash _.defaultsDeep */
+        export function deepSupplement(objects: any, defaultIndicator?: any): any;
+
+        // Private functions
+        /** @deprecated use lodash _.assign */
+        export function mixin(objects: any[]): any;
+        /** @deprecated use lodash _.defaults */
+        export function supplement(objects: any[]): any;
+        /** @deprecated use lodash _.mixin  */
+        export function deepMixin(objects: any[]): any;
     }
 
-}
+    namespace layout {
+
+        interface LayoutOptions {
+            nodeSep?: number;
+            edgeSep?: number;
+            rankSep?: number;
+            rankDir?: 'TB' | 'BT' | 'LR' | 'RL';
+            marginX?: number;
+            marginY?: number;
+            resizeCluster?: boolean;
+            setPosition?: (element: dia.Element, position: dia.BBox) => void;
+            setLinkVertices?: (link: dia.Link, vertices: Position[]) => void;
+        }
+
+        class DirectedGraph {
+            static layout(graph: dia.Graph, options?: LayoutOptions): dia.BBox;
+        }
+    }
+}

jquery.datatables/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for JQuery DataTables 1.10.7
+// Type definitions for JQuery DataTables 1.10.8
 // Project: http://www.datatables.net
 // Definitions by: Kiarash Ghiaseddin <https://github.com/Silver-Connection/DefinitelyTyped>, Omid Rad <https://github.com/omidkrad>, Armin Sander <https://github.com/pragmatrix/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -182,11 +182,11 @@ declare namespace DataTables {
         destroy(remove?: boolean): DataTable;
 
         /**
-        * Redraw the table.
+        * Redraw the DataTables in the current context, optionally updating ordering, searching and paging as required.
         *
-        * @param reset Reset (default) or hold the current paging position. A full re-sort and re-filter is performed when this method is called, which is why the pagination reset is the default action.
+        * @param paging This parameter is used to determine what kind of draw DataTables will perform.
         */
-        draw(reset?: boolean): DataTable;
+        draw(paging?: boolean | string): DataTable;
 
         /*
         * Look up a language token that was defined in the DataTables' language initialisation object.
@@ -374,6 +374,7 @@ declare namespace DataTables {
         length: number;
         recordsTotal: number;
         recordsDisplay: number;
+        serverSide: boolean
     }
 
     //#endregion "page-methods"
@@ -436,6 +437,11 @@ declare namespace DataTables {
         */
         concat(a: Object, ...b: Object[]): DataTable;
 
+        /**
+        * Get the number of entries in an API instance's result set, regardless of multi-table grouping (e.g. any data, selected rows, etc). Since: 1.10.8
+        */
+        count(): number;
+
         /**
         * Iterate over the contents of the API result set.
         *
@@ -910,6 +916,15 @@ declare namespace DataTables {
         */
         id(hash?: boolean): string;
 
+        /**
+        * Get the id of the selected row. Since: 1.10.8
+        *
+        * @param hash true - Append a hash (#) to the start of the row id. This can be useful for then using the id as a selector
+        * false - Do not modify the id value.
+        * @returns Row id. If the row does not have an id available 'undefined' will be returned.
+        */
+        id(hash?: boolean): string;
+
         /**
         * Get the row index of the row column.
         */
@@ -970,6 +985,15 @@ declare namespace DataTables {
         */
         every(fn: (rowIdx: number, tableLoop: number, rowLoop: number) => void): DataTable;
 
+        /**
+        * Get the ids of the selected rows. Since: 1.10.8
+        *
+        * @param hash true - Append a hash (#) to the start of each row id. This can be useful for then using the ids as selectors
+        * false - Do not modify the id value.
+        * @returns Api instance with the selected rows in its result set. If a row does not have an id available 'undefined' will be returned as the value.
+        */
+        ids(hash?: boolean): DataTable;
+
         /**
         * Get the row indexes of the selected rows.
         */
@@ -1057,11 +1081,12 @@ declare namespace DataTables {
         isDataTable(table: string): boolean;
 
         /**
-        * Get all DataTables on the page
+        * Get all DataTable tables that have been initialised - optionally you can select to get only currently visible tables and / or retrieve the tables as API instances.
         *
-        * @param visible Get only visible tables
+        * @param visible As a boolean value this options is used to indicate if you want all tables on the page should be returned (false), or visible tables only (true).
+        * Since 1.10.8 this option can also be given as an object.
         */
-        tables(visible?: boolean): DataTables.DataTable[];
+        tables(visible?: boolean | ObjectTablesStatic): DataTables.DataTable[] | DataTables.DataTable;
 
         /**
         * Version number compatibility check function
@@ -1100,6 +1125,18 @@ declare namespace DataTables {
         throttle(fn: Function, period?: number): Function;
     }
 
+    interface ObjectTablesStatic {
+        /**
+        * Get only visible tables (true) or all tables regardless of visibility (false).
+        */
+        visible: boolean
+
+        /**
+        * Return a DataTables API instance for the selected tables (true) or an array (false).
+        */
+        api: boolean
+    }
+
     //#endregion "Static-Methods"
 
     //#region "Settings"
@@ -1257,7 +1294,7 @@ declare namespace DataTables {
         pageLength?: number;
 
         /**
-        * Pagination button display options. Basic Types: simple, simple_numbers, full, full_numbers
+        * Pagination button display options. Basic Types: numbers (1.10.8) simple, simple_numbers, full, full_numbers
         */
         pagingType?: string;
 
@@ -1271,6 +1308,11 @@ declare namespace DataTables {
         */
         renderer?: string | RendererSettings;
 
+        /**
+        * Data property name that DataTables will use to set <tr> element DOM IDs. Since: 1.10.8
+        */
+        rowId?: string;
+
         /**
         * Allow the table to reduce in height when a limited number of rows are shown. Since: 1.10
         */

jquery.datatables/jquery.dataTables-tests.ts

@@ -219,6 +219,7 @@ $(document).ready(function () {
             pagingType: "simple",
             retrieve: true,
             renderer: "bootstrap",
+            rowId: "custId",
             scrollCollapse: true,
             search: true,
             searchCols: [{ "search": "", "smart": true, "regex": false, "caseInsensitive": true }],
@@ -261,7 +262,7 @@ $(document).ready(function () {
     {
         ajax: {
             data: ajaxDataFunc,
-            dataSrc: function (data) { },
+                dataSrc: function (data: any) { },
         },
     };
 
@@ -305,8 +306,9 @@ $(document).ready(function () {
     destroy = dt.destroy(true);
     destroy.$("");
 
-    var draw = dt.draw();
+    var draw: DataTables.DataTable = dt.draw();
     draw = dt.draw(true);
+    draw = dt.draw("page");
     draw.$("");
 
     var initSettings = dt.init();
@@ -343,7 +345,8 @@ $(document).ready(function () {
         "end": 20,
         "length": 10,
         "recordsTotal": 57,
-        "recordsDisplay": 57
+        "recordsDisplay": 57,
+        "serverSide": false
     };
 
     var page_len_get = dt.page.len();
@@ -401,7 +404,7 @@ $(document).ready(function () {
         .cache('search')
         .sort()
         .unique()
-        .each(function (d) {
+        .each(function (d: any) {
         select.append($('<option value="' + d + '">' + d + '</option>'));
     });
 
@@ -520,7 +523,7 @@ $(document).ready(function () {
     columns = dt.columns("selector", modifier);
 
     var columns_cache = columns.cache("order");
-    dt.columns('.select-filter').eq(0).each(function (colIdx) {
+    dt.columns('.select-filter').eq(0).each(function (colIdx: any) {
         // Create the select list and search operation
         var select = $('<select />')
             .appendTo(
@@ -539,7 +542,7 @@ $(document).ready(function () {
             .cache('search')
             .sort()
             .unique()
-            .each(function (d) {
+            .each(function (d: any) {
             select.append($('<option value="' + d + '">' + d + '</option>'));
         });
     });
@@ -623,7 +626,7 @@ $(document).ready(function () {
         .cache('search')
         .sort()
         .unique()
-        .each(function (d) {
+        .each(function (d: any) {
         select.append($('<option value="' + d + '">' + d + '</option>'));
     });
 
@@ -632,7 +635,7 @@ $(document).ready(function () {
         dt
             .column(4)
             .data()
-    .reduce(function (a, b) {
+            .reduce(function (a: any, b: any) {
     return a + b;
     })
         );
@@ -688,7 +691,7 @@ $(document).ready(function () {
             .draw();
     });
 
-    dt.columns('.select-filter').eq(0).each(function (colIdx) {
+    dt.columns('.select-filter').eq(0).each(function (colIdx: any) {
         // Create the select list and search operation
         var select = $('<select />')
             .appendTo(
@@ -707,7 +710,7 @@ $(document).ready(function () {
             .cache('search')
             .sort()
             .unique()
-            .each(function (d) {
+            .each(function (d: any) {
             select.append($('<option value="' + d + '">' + d + '</option>'));
         });
     });
@@ -751,6 +754,8 @@ $(document).ready(function () {
     var row_19 = dt.row("selector").index();
     var row_20 = dt.row("selector").node();
     var row_21 = dt.row("selector").remove();
+    var row_22: string = dt.row("selector").id();
+    var row_23: string = dt.row("selector").id(false);
 
     var rows_1 = dt.rows();
     var rows_2 = dt.rows().remove();
@@ -767,6 +772,8 @@ $(document).ready(function () {
     var rows_13 = dt.rows.add([{}, {}]);
     dt.rows().every(function () { });
     dt.rows().every(function (rowIdx, tableLoop, rowLoop) { });
+    var rows_14: DataTables.DataTable = dt.rows("selector").ids();
+    var rows_15: DataTables.DataTable = dt.rows("selector").ids(false);
 
     var table3 = $('#example').DataTable();
     table3.row.add({
@@ -831,7 +838,7 @@ $(document).ready(function () {
     ])
         .show();
 
-    dt.rows().eq(0).each(function (rowIdx) {
+    dt.rows().eq(0).each(function (rowIdx: any) {
         dt
             .row(rowIdx)
             .child(
@@ -881,6 +888,20 @@ $(document).ready(function () {
 
     //#endregion "Methods-Row"
 
+    //#region "Methods-Static"
+
+    // Variable is a stand-in for $.fn.dataTable. See extension of JQueryStatic at the top of jquery.dataTables.d.ts.
+    var staticFn: DataTables.StaticFunctions;
+
+    // With boolean parameter type, always returns DataTables.DataTable[].
+    var static_1: DataTables.DataTable[] = <DataTables.DataTable[]>staticFn.tables(true);
+    // With object parameter type, returns DataTables.DataTable[] when "api" property is false.
+    static_1 = <DataTables.DataTable[]>staticFn.tables({ "visible": true, "api": false });
+    // With object parameter type, returns DataTables.DataTable when "api" property is true.
+    var static_2: DataTables.DataTable = <DataTables.DataTable>staticFn.tables({ "visible": true, "api": true });
+
+    //#endregion "Methods-Static"
+
     //#region "Methods-Table"
 
     var tables = dt.tables();
@@ -905,6 +926,7 @@ $(document).ready(function () {
     //#region "Methods-Util"
 
     var util_1: boolean = dt.any();
+    var util_2: number = dt.count();
 
     //#endregion "Methods-Util"
 });

jquery.rateit/index.d.ts

@@ -0,0 +1,45 @@
+// Type definitions for jquery.rateit.js 1.1.1
+// Project: https://github.com/gjunge/rateit.js
+// Definitions by: Gidon Junge <https://github.com/gjunge>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="jquery"/>
+type RateItMode = "bg" | "font";
+interface RateItOptions {
+ value? : number;
+ min?: number;
+ max?: number;
+ step?:number;
+ backingfld?:string;
+ readonly?:boolean;
+ ispreset? : boolean;
+ resetable? : boolean;
+ starwidth?: number;
+ starheight?: number;
+ mode?: RateItMode;
+ icon?: string;
+}
+
+interface JQuery {
+    rateit() : JQuery;
+    rateit(options: RateItOptions) : JQuery;
+
+    rateit(method: 'value') : number;
+    rateit(method: 'value', param: number) : JQuery;
+
+    rateit(method: 'max') : number;
+    rateit(method: 'max', param: number) : JQuery;
+
+    rateit(method: 'min') : number;
+    rateit(method: 'min', param: number) : JQuery;
+
+    rateit(method: 'readonly') : boolean;
+    rateit(method: 'readonly', param: boolean) : JQuery;
+
+    rateit(method: 'ispreset') : boolean;
+    rateit(method: 'ispreset', param: boolean) : JQuery;
+
+    rateit(method: 'reset') : JQuery;
+
+    rateit(method: string, param: any) : any;
+}

jquery.rateit/jquery.rateit-tests.ts

@@ -0,0 +1,46 @@
+var rateit_simple = $('.rateit').rateit();
+
+var rateit_properties_font = $('.rateit').rateit({
+    backingfld: '#backingfield',
+    icon: '@',
+    mode: 'font',
+    ispreset: false,
+    max: 5,
+    min: 0,
+    readonly: false,
+    resetable: false,
+    step: 0.5,
+    value: 2
+});
+
+var rateit_properties_bg = $('.rateit').rateit({
+    backingfld: '#backingfield',
+    mode: 'bg',
+    ispreset: false,
+    max: 5,
+    min: 0,
+    readonly: false,
+    resetable: false,
+    step: 0.5,
+    value: 2,
+    starheight: 16,
+    starwidth: 16
+});
+
+//getters
+var val : number = rateit_properties_bg.rateit('value');
+var min : number = rateit_properties_bg.rateit('min');
+var max : number = rateit_properties_bg.rateit('max');
+var readonly :boolean = rateit_properties_bg.rateit('readonly');
+var ispreset :boolean = rateit_properties_bg.rateit('ispreset');
+
+
+//setters
+rateit_properties_bg.rateit('value',4);
+rateit_properties_bg.rateit('min',0);
+rateit_properties_bg.rateit('max',6);
+rateit_properties_bg.rateit('readonly',true);
+rateit_properties_bg.rateit('ispreset',false);
+
+//reset it
+rateit_properties_bg.rateit('reset');

jquery.rateit/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "jquery.rateit-tests.ts"
+    ]
+}

jsonstream/tsconfig.json

@@ -14,6 +14,6 @@
     },
     "files": [
         "index.d.ts",
-        "JSONStream-tests.ts"
+        "jsonstream-tests.ts"
     ]
-}
+}

kafka-node/index.d.ts

@@ -9,6 +9,7 @@
 export declare class Client {
     constructor(connectionString: string, clientId: string, options?: ZKOptions);
     close(callback?: Function): void;
+    topicExists(topics: Array<string>, callback: Function): void;
 }
 
 export declare class Producer {

kefir/index.d.ts

@@ -1,11 +1,20 @@
-// Type definitions for Kefir 3.2.0
+// Type definitions for Kefir 3.3.0
 // Project: http://rpominov.github.io/kefir/
 // Definitions by: Aya Morisawa <https://github.com/AyaMorisawa>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="node" />
 
+export interface Subscription {
+    unsubscribe(): void;
+    closed: boolean; // Actually, `readonly` but it's avaiable in tsc starting with 2.0.0
+}
 
+export interface Observer<T, S> {
+    value?: (value: T) => void;
+    error?: (error: S) => void;
+    end?: () => void;
+}
 
 export interface Observable<T, S> {
     // Subscribe / add side effects
@@ -22,6 +31,13 @@ export interface Observable<T, S> {
     flatten<U>(transformer?: (value: T) => U[]): Stream<U, S>;
     toPromise(PromiseConstructor?: any): any;
     toESObservable(): any;
+    // This method is designed to replace all other methods for subscribing
+    observe(params: Observer<T, S>): Subscription;
+    observe(
+        onValue?: (value: T) => void,
+        onError?: (error: S) => void,
+        onEnd?: () => void
+    ): Subscription;
 }
 
 export interface Stream<T, S> extends Observable<T, S> {

kefir/kefir-tests.ts

@@ -69,6 +69,19 @@ import { Observable, ObservablePool, Stream, Property, Event, Emitter } from 'ke
 	Kefir.sequentially(1000, [1, 2]).log('my stream');
 	Kefir.sequentially(1000, [1, 2]).offLog('my stream');
 	Kefir.sequentially(1000, [1, 2]).toPromise().then((x: number) => console.log('fulfilled with:', x));
+	Kefir.sequentially(1000, [1, 2]).observe({});
+	Kefir.sequentially(1000, [1, 2]).observe({
+		value: _ => {},
+		error: _ => {},
+		end: () => {},
+	});
+	Kefir.sequentially(1000, [1, 2]).observe();
+	const subscription = Kefir.sequentially(1000, [1, 2]).observe(
+		_ => {},
+		_ => {},
+		() => {}
+	);
+	if (!subscription.closed) subscription.unsubscribe();
 }
 
 // Modify an observable

keymirror/index.d.ts

@@ -0,0 +1,7 @@
+// Type definitions for keymirror 0.1.1
+// Project: https://github.com/STRML/keyMirror
+// Definitions by: Johannes Fahrenkrug <https://github.com/jfahrenkrug>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare function KeyMirror(obj: {}): { [key: string]: string };
+export = KeyMirror;

keymirror/keymirror-tests.ts

@@ -0,0 +1,3 @@
+import keyMirror = require('keymirror');
+
+keyMirror({key1: null, key2: null});

keymirror/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "keymirror-tests.ts"
+    ]
+}

koa/index.d.ts

@@ -161,6 +161,7 @@ declare class Koa extends EventEmitter {
     constructor();
 
     // From node.d.ts
+    listen(): http.Server;
     listen(port: number, hostname?: string, backlog?: number, listeningListener?: Function): http.Server;
     listen(port: number, hostname?: string, listeningListener?: Function): http.Server;
     listen(port: number, backlog?: number, listeningListener?: Function): http.Server;

koa/koa-tests.ts

@@ -19,3 +19,5 @@ app.use(ctx => {
 });
 
 app.listen(3000);
+
+const server = app.listen();

leaflet/index.d.ts

@@ -5,7 +5,43 @@
 
 /// <reference types="geojson" />
 
+type NativeMouseEvent = MouseEvent;
+
 declare namespace L {
+    export class Class {
+        static extend(props:any):any/* how to return constructor of self extended type ? */;
+        static include(props:any):any /* how to return self extended type ? */;
+        static mergeOptions(props:any): any /* how to return self extended type ? */;
+        static addInitHook(initHookFn: ()=> void): any/* how to return self extended type ? */;
+    }
+
+    export class DomUtil {
+        static get(id: string): HTMLElement;
+        static get(id: HTMLElement): HTMLElement;
+        static getStyle(el: HTMLElement, styleAttrib: string): string;
+        static create(tagName: String, className?: String, container?: HTMLElement): HTMLElement;
+        static remove(el: HTMLElement):void;
+        static empty(el: HTMLElement):void;
+        static toFront(el: HTMLElement):void;
+        static toBack(el: HTMLElement):void;
+        static hasClass(el: HTMLElement, name: String): Boolean;
+        static addClass(el: HTMLElement, name: String):void;
+        static removeClass(el: HTMLElement, name: String):void;
+        static setClass(el: HTMLElement, name: String):void;
+        static getClass(el: HTMLElement): String;
+        static setOpacity(el: HTMLElement, opacity: Number):void;
+        static testProp(props: String[]): String|boolean/*=false*/;
+        static setTransform(el: HTMLElement, offset: Point, scale?: Number):void;
+        static setPosition(el: HTMLElement, position: Point):void;
+        static getPosition(el: HTMLElement): Point
+        static disableTextSelection(): void
+        static enableTextSelection(): void
+        static disableImageDrag(): void
+        static enableImageDrag(): void
+        static preventOutline(el: HTMLElement): void
+        static restoreOutline(): void
+    }
+
     export interface CRS {
         latLngToPoint(latlng: LatLng, zoom: number): Point;
         latLngToPoint(latlng: LatLngLiteral, zoom: number): Point;
@@ -211,7 +247,7 @@ declare namespace L {
      * with an object (e.g. the user clicks on the map, causing the map to fire
      * 'click' event).
      */
-    export interface Evented {
+    export interface Evented extends Class {
         /**
          * Adds a listener function (fn) to a particular event type of the object.
          * You can optionally specify the context of the listener (object the this
@@ -1125,7 +1161,7 @@ declare namespace L {
         latlng: LatLng;
         layerPoint: Point;
         containerPoint: Point;
-        originalEvent: MouseEvent; // how can I reference the global MouseEvent?
+        originalEvent: NativeMouseEvent;
     }
 
     export interface LocationEvent extends Event {

libxmljs/index.d.ts

@@ -17,13 +17,13 @@ export declare function parseHtmlString(source: string): HTMLDocument;
 
 export declare class XMLDocument {
     constructor(version: number, encoding: string);
-    child(idx: number): Element;
+    child(idx: number): Element | undefined;
     childNodes(): Element[];
     errors(): SyntaxError[];
     encoding(): string;
     encoding(enc: string): void;
     find(xpath: string): Element[];
-    get(xpath: string): Element;
+    get(xpath: string): Element | undefined;
     node(name: string, content: string): Element;
     root(): Element;
     toString(): string;
@@ -48,7 +48,7 @@ export declare class Element {
     attrs(): Attribute[];
     parent(): Element;
     doc(): XMLDocument;
-    child(idx: number): Element;
+    child(idx: number): Element | undefined;
     childNodes(): Element[];
     addChild(child: Element): Element;
     nextSibling(): Element;
@@ -60,9 +60,9 @@ export declare class Element {
     find(xpath: string): Element[];
     find(xpath: string, ns_uri: string): Element[];
     find(xpath: string, namespaces: { [key: string]: string; }): Element[];
-    get(xpath: string): Element;
-    get(xpath: string, ns_uri: string): Element;
-    get(xpath: string, ns_uri: { [key: string]: string; }): Element;
+    get(xpath: string): Element | undefined;
+    get(xpath: string, ns_uri: string): Element | undefined;
+    get(xpath: string, ns_uri: { [key: string]: string; }): Element | undefined;
     defineNamespace(href: string): Namespace;
     defineNamespace(prefix: string, href: string): Namespace;
     namespace(): Namespace;

lodash/index.d.ts

@@ -10986,7 +10986,7 @@ declare module _ {
          * @param value The value to inspect.
          * @return Returns the cast array.
          */
-        castArray<T>(value: T): T[];
+        castArray<T>(value?: T | T[]): T[];
     }
 
     interface LoDashImplicitWrapper<T> {

lowlight/index.d.ts

@@ -0,0 +1,99 @@
+// Type definitions for lowlight
+// Project: https://github.com/wooorm/lowlight
+// Definitions by: Ivo Stratev <https://github.com/NoHomey>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module 'lowlight' {
+    export { highlight, highlightAuto, registerLanguage } from 'lowlight/lib/core';
+}
+
+declare module 'lowlight/lib/core' {
+    export function highlight(language: string, value: string, options?: lowlight.HighlightOptions): lowlight.HighlightResult;
+    export function highlightAuto(value: string, options?: lowlight.HighlightAutoOptions): lowlight.HighlightAutoResult;
+    export function registerLanguage(name: string, syntax: Function): void;
+}
+
+declare namespace lowlight {
+    namespace AST {
+        namespace Unist {
+            interface Data {
+                [index: string]: any;
+            }
+
+            interface Position {
+                line: number;
+                column: number;
+                offset?: number;
+            }
+
+            interface Location {
+                start: Position;
+                end: Position;
+                indent?: Array<number>;
+            }
+
+            export interface Node {
+                type: string;
+                data?: Data;
+                position?: Location;
+            }
+
+            export interface Parent extends Node {
+                children: Array<Node>;
+            }
+
+            export interface Text extends Node {
+                value: string;
+            }
+        }
+
+        interface Properties {
+            [index: string]: any;
+        }
+
+        export interface Root extends Unist.Parent {
+            type: 'root';
+        }
+
+        export interface Element extends Unist.Parent {
+            type: 'element';
+            tagName: string;
+            properties: Properties;
+        }
+
+        export interface Doctype extends Unist.Node {
+            type: 'doctype';
+            name: string;
+            public?: string;
+            system?: string;
+        }
+
+        export interface Comment extends Unist.Text {
+                type: 'comment';
+        }
+
+        export interface Text extends Unist.Text {
+            type: 'text';
+        }
+    }
+
+    type HastNode = AST.Root | AST.Element | AST.Doctype | AST.Comment | AST.Text;
+
+    interface HighlightOptions {
+            prefix?: string;
+    }
+
+    interface HighlightAutoOptions extends HighlightOptions {
+        subset?: Array<string>;
+    }
+
+    interface HighlightResult {
+        relevance: number;
+        language: string;
+        value: Array<HastNode>;
+    }
+
+    interface HighlightAutoResult extends HighlightResult {
+        secondBest?: HighlightAutoResult;
+    }
+}

lowlight/lowlight-tests.ts

@@ -0,0 +1,80 @@
+import { highlight, highlightAuto, registerLanguage } from 'lowlight';
+import * as core from 'lowlight/lib/core';
+
+function highlighter(hljs: any): any {
+    return {
+        aliases: ['cmake.in'],
+        case_insensitive: true,
+        keywords: {
+            keyword:
+                'forall all exists exist only m M i e 1 2 3 4 5 6 7 8 9 0 - + * / \ % ! . , ; : | lim limsup liminf infinity not'
+        },
+        contains: [
+        {
+            className: 'variable',
+            begin: '(', end: ')'
+        },
+        ]
+    };
+}
+
+registerLanguage('math', highlighter);
+
+console.log(highlight('typescript',
+`class CPP {
+    private year: number;
+    public constructor(private version: string) {
+        this.year = Number(version.match(/.+\d+$/));
+    }
+
+    public version(): string {
+        return this.version;
+    }
+}
+`
+));
+
+console.info(highlightAuto(
+`class CPP {
+    private year: number;
+    public constructor(private version: string) {
+        this.year = Number(version.match(/.+\d+$/));
+    }
+
+    public version(): string {
+        return this.version;
+    }
+}
+`
+));
+
+core.registerLanguage('math', highlighter);
+
+console.log(core.highlight('javascript',
+`class CPP {
+    constructor(version) {
+        this.version = version;
+        this.year = Number(version.match(/.+\d+$/));
+    }
+
+    version(){
+        return this.version;
+    }
+}
+`
+, { prefix: 'core-' }));
+
+
+console.info(core.highlightAuto(
+`class CPP {
+    constructor(version) {
+        this.version = version;
+        this.year = Number(version.match(/.+\d+$/));
+    }
+
+    version(){
+        return this.version;
+    }
+}
+`
+, { prefix: 'core-', subset: ['purescript', 'javascript', 'typescript', 'coffeescript'] }));

lowlight/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "lowlight-tests.ts"
+    ]
+}

mapbox-gl/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Mapbox GL JS v0.24.0
+// Type definitions for Mapbox GL JS v0.26.0
 // Project: https://github.com/mapbox/mapbox-gl-js
 // Definitions by: Dominik Bruderer <https://github.com/dobrud>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -343,28 +343,28 @@ declare namespace mapboxgl {
 	/**
 	 * Navigation
 	 */
-	export class Navigation extends Control {
+	export class NavigationControl extends Control {
 		constructor(options?: mapboxgl.ControlOptions);
 	}
 
 	/**
 	 * Geolocate
 	 */
-	export class Geolocate extends Control {
+	export class GeolocateControl extends Control {
 		constructor(options?: mapboxgl.ControlOptions);
 	}
 
 	/**
 	 * Attribution
 	 */
-	export class Attribution extends Control {
+	export class AttributionControl extends Control {
 		constructor(options?: mapboxgl.ControlOptions);
 	}
 
 	/**
 	 * Scale
 	 */
-	export class Scale extends Control {
+	export class ScaleControl extends Control {
 		constructor(options?: {position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left', maxWidth?: number, unit?: string})
 	}
 
@@ -697,6 +697,11 @@ declare namespace mapboxgl {
 		boxZoomBounds: LngLatBounds;
 	}
 
+	export class MapDataEvent {
+		type: string;
+		dataType: "source" | "style" | "tile";
+	}
+
 	/**
 	 * AnimationOptions
 	 */
@@ -741,8 +746,12 @@ declare namespace mapboxgl {
 	 * MapEvent
 	 */
 	export interface MapEvent {
+		resize?: void;
 		webglcontextlost?: {originalEvent: WebGLContextEvent};
 		webglcontextrestored?: {originalEvent: WebGLContextEvent};
+		remove?: void;
+		dataloading?: {data: mapboxgl.MapDataEvent};
+		data?: {data: mapboxgl.MapDataEvent};
 		render?: void;
 		contextmenu?: {data: mapboxgl.MapMouseEvent};
 		dblclick?: {data: mapboxgl.MapMouseEvent};
@@ -798,7 +807,8 @@ declare namespace mapboxgl {
 		stops: any[][];
 		property?: string;
 		base?: number;
-		type?: "continuous" | "interval" | "categorical";
+		type?: "identity" | "exponential" | "interval" | "categorical";
+		"colorSpace"?: "rgb" | "lab" | "interval";
 	}
 
 	export interface BackgroundLayout {
@@ -821,6 +831,8 @@ declare namespace mapboxgl {
 		"fill-translate"?: number[];
 		"fill-translate-anchor"?: "map" | "viewport";
 		"fill-pattern"?: "string";
+		"fill-extrude-height"?: number;
+		"fill-extrude-base"?: number;
 	}
 
 	export interface LineLayout {

mapbox-gl/mapbox-gl-0.25.1.d.ts

@@ -0,0 +1,936 @@
+// Type definitions for Mapbox GL JS v0.24.0
+// Project: https://github.com/mapbox/mapbox-gl-js
+// Definitions by: Dominik Bruderer <https://github.com/dobrud>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../geojson/geojson.d.ts" />
+
+declare namespace mapboxgl {
+	let accessToken: string;
+	let version: string;
+	export function supported(options?: {failIfMajorPerformanceCaveat?: boolean}): boolean;
+
+	/**
+	 * Map
+	 */
+	export class Map extends Evented {
+		constructor(options?: MapboxOptions);
+
+		addControl(control: Control): this;
+
+		addClass(klass: string, options?: mapboxgl.StyleOptions): this;
+
+		removeClass(klass: string, options?: mapboxgl.StyleOptions): this;
+
+		setClasses(klasses: string[], options?: mapboxgl.StyleOptions): this;
+
+		hasClass(klass: string): boolean;
+
+		getClasses(): string[];
+
+		resize(): this;
+
+		getBounds(): mapboxgl.LngLatBounds;
+
+		setMaxBounds(lnglatbounds?: mapboxgl.LngLatBounds | number[][]): this;
+
+		setMinZoom(minZoom?: number): this;
+
+		setMaxZoom(maxZoom?: number): this;
+
+		project(lnglat: mapboxgl.LngLat | number[]): mapboxgl.Point;
+
+		unproject(point: mapboxgl.Point | number[]): mapboxgl.LngLat;
+
+		queryRenderedFeatures(pointOrBox?: mapboxgl.Point|number[]|mapboxgl.Point[]|number[][], parameters?: {layers?: string[], filter?: any[]}): GeoJSON.Feature<GeoJSON.GeometryObject>[];
+
+		querySourceFeatures(sourceID: string, parameters: {sourceLayer?: string, filter?: any[]}): GeoJSON.Feature<GeoJSON.GeometryObject>[];
+
+		setStyle(style: mapboxgl.Style | string): this;
+
+		getStyle(): mapboxgl.Style;
+
+		addSource(id: string, source: VectorSource | RasterSource | GeoJSONSource | ImageSource | VideoSource | GeoJSONSourceRaw): this;
+
+		removeSource(id: string): this;
+
+		getSource(id: string): VectorSource | RasterSource | GeoJSONSource | ImageSource | VideoSource;
+
+		addLayer(layer: mapboxgl.Layer, before?: string): this;
+
+		removeLayer(id: string): this;
+
+		getLayer(id: string): mapboxgl.Layer;
+
+		setFilter(layer: string, filter: any[]): this;
+
+		setLayerZoomRange(layerId: string, minzoom: number, maxzoom: number): this;
+
+		getFilter(layer: string): any[];
+
+		setPaintProperty(layer: string, name: string, value: any, klass?: string): this;
+
+		getPaintProperty(layer: string, name: string, klass?: string): any;
+
+		setLayoutProperty(layer: string, name: string, value: any): this;
+
+		getLayoutProperty(layer: string, name: string, klass?: string): any;
+
+		getContainer(): HTMLElement;
+
+		getCanvasContainer(): HTMLElement;
+
+		getCanvas(): HTMLCanvasElement;
+
+		loaded(): boolean;
+
+		remove(): void;
+
+		onError(): void;
+
+		showTileBoundaries: boolean;
+
+		showCollisionBoxes: boolean;
+
+		repaint: boolean;
+
+		getCenter(): mapboxgl.LngLat;
+
+		setCenter(center: LngLat|number[], eventData?: mapboxgl.EventData): this;
+
+		panBy(offset: number[], options?: mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		panTo(lnglat: mapboxgl.LngLat, options?: mapboxgl.AnimationOptions, eventdata?: mapboxgl.EventData): this;
+
+		getZoom(): number;
+
+		setZoom(zoom: number, eventData?: mapboxgl.EventData): this;
+
+		zoomTo(zoom: number, options?: mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		zoomIn(options?: mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		zoomOut(options?: mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		getBearing(): number;
+
+		setBearing(bearing: number, eventData?: mapboxgl.EventData): this;
+
+		rotateTo(bearing: number, options?: mapboxgl.AnimationOptions, eventData?: EventData): this;
+
+		resetNorth(options?: mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		snapToNorth(options?: mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		getPitch(): number;
+
+		setPitch(pitch: number, eventData?: EventData): this;
+
+		fitBounds(bounds: mapboxgl.LngLatBounds | number[][], options?: { linear?: boolean, easing?: Function, padding?: number, offset?: Point|number[],maxZoom?: number }): this;
+
+		jumpTo(options: mapboxgl.CameraOptions, eventData?: mapboxgl.EventData): this;
+
+		easeTo(options: mapboxgl.CameraOptions | mapboxgl.AnimationOptions, eventData?: mapboxgl.EventData): this;
+
+		flyTo(options: mapboxgl.FlyToOptions, eventData?: mapboxgl.EventData): this;
+
+		stop(): this;
+
+		scrollZoom: ScrollZoomHandler;
+
+		boxZoom: BoxZoomHandler;
+
+		dragRotate: DragRotateHandler;
+
+		dragPan: DragPanHandler;
+
+		keyboard: KeyboardHandler;
+
+		doublClickZoom: DoubleClickZoomHandler;
+
+		touchZoomRotate: TouchZoomRotateHandler;
+	}
+
+	export interface MapboxOptions {
+		/** If true, an attribution control will be added to the map. */
+		attributionControl?: boolean;
+
+		bearing?: number;
+
+		/** Snap to north threshold in degrees. */
+		bearingSnap?: number;
+
+		/** If true, enable the "box zoom" interaction (see BoxZoomHandler) */
+		boxZoom?: boolean;
+
+		/** initial map center */
+		center?: mapboxgl.LngLat | number[];
+
+		/** Style class names with which to initialize the map */
+		classes?: string[];
+
+		/** ID of the container element */
+		container?: string | Element;
+
+		/** If true, enable the "drag to pan" interaction (see DragPanHandler). */
+		dragPan?: boolean;
+
+		/** If true, enable the "drag to rotate" interaction (see DragRotateHandler). */
+		dragRotate?: boolean;
+
+		/** If true, enable the "double click to zoom" interaction (see DoubleClickZoomHandler). */
+		doubleClickZoom?: boolean;
+
+		/** If true, the map will track and update the page URL according to map position */
+		hash?: boolean;
+
+		/** If true, map creation will fail if the implementation determines that the performance of the created WebGL context would be dramatically lower than expected. */
+		failIfMayorPerformanceCaveat?: boolean;
+
+		/** If false, no mouse, touch, or keyboard listeners are attached to the map, so it will not respond to input */
+		interactive?: boolean;
+
+		/** If true, enable keyboard shortcuts (see KeyboardHandler). */
+		keyboard?: boolean;
+
+		/** If set, the map is constrained to the given bounds. */
+		maxBounds?: mapboxgl.LngLatBounds | number[][];
+
+		/** Maximum zoom of the map */
+		maxZoom?: number;
+
+		/** Minimum zoom of the map */
+		minZoom?: number;
+
+		/** If true, The maps canvas can be exported to a PNG using map.getCanvas().toDataURL();. This is false by default as a performance optimization. */
+		preserveDrawingBuffer?: boolean;
+
+		pitch?: number;
+
+		/** If true, enable the "scroll to zoom" interaction */
+		scrollZoom?: boolean;
+
+		/** stylesheet location */
+		style?: mapboxgl.Style | string;
+
+		/** If  true, the map will automatically resize when the browser window resizes */
+		trackResize?: boolean;
+
+		/** If true, enable the "pinch to rotate and zoom" interaction (see TouchZoomRotateHandler). */
+		touchZoomRotate?: boolean;
+
+		/** Initial zoom level */
+		zoom?: number;
+	}
+
+	/**
+	 * BoxZoomHandler
+	 */
+	export class BoxZoomHandler {
+		constructor(map: mapboxgl.Map);
+
+		isEnabled(): boolean;
+
+		isActive(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+	}
+
+	/**
+	 * ScrollZoomHandler
+	 */
+	export class ScrollZoomHandler {
+		constructor(map: mapboxgl.Map);
+
+		isEnabled(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+	}
+
+	/**
+	 * DragPenHandler
+	 */
+	export class DragPanHandler {
+		constructor(map: mapboxgl.Map);
+
+		isEnabled(): boolean;
+
+		isActive(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+	}
+
+	/**
+	 * DragRotateHandler
+	 */
+	export class DragRotateHandler {
+		constructor(map: mapboxgl.Map, options?: {bearingSnap?: number, pitchWithRotate?: boolean});
+
+		isEnabled(): boolean;
+
+		isActive(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+	}
+
+	/**
+	 * KeyboardHandler
+	 */
+	export class KeyboardHandler {
+		constructor(map: mapboxgl.Map);
+
+		isEnabled(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+	}
+
+	/**
+	 * DoubleClickZoomHandler
+	 */
+	export class DoubleClickZoomHandler {
+		constructor(map: mapboxgl.Map);
+
+		isEnabled(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+	}
+
+	/**
+	 * TouchZoomRotateHandler
+	 */
+	export class TouchZoomRotateHandler {
+		constructor(map: mapboxgl.Map);
+
+		isEnabled(): boolean;
+
+		enable(): void;
+
+		disable(): void;
+
+		disableRotation(): void;
+
+		enableRotation(): void;
+	}
+
+	/**
+	 * Control
+	 */
+	export class Control extends Evented {
+		addTo(map: mapboxgl.Map): this;
+
+		remove(): this;
+	}
+
+	/**
+	 * ControlOptions
+	 */
+	export interface ControlOptions {
+		position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+	}
+
+	/**
+	 * Navigation
+	 */
+	export class Navigation extends Control {
+		constructor(options?: mapboxgl.ControlOptions);
+	}
+
+	/**
+	 * Geolocate
+	 */
+	export class Geolocate extends Control {
+		constructor(options?: mapboxgl.ControlOptions);
+	}
+
+	/**
+	 * Attribution
+	 */
+	export class Attribution extends Control {
+		constructor(options?: mapboxgl.ControlOptions);
+	}
+
+	/**
+	 * Scale
+	 */
+	export class Scale extends Control {
+		constructor(options?: {position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left', maxWidth?: number, unit?: string})
+	}
+
+	/**
+	 * Popup
+	 */
+	export class Popup extends Evented {
+		constructor(options?: mapboxgl.PopupOptions);
+
+		addTo(map: mapboxgl.Map): this;
+
+		isOpen(): boolean;
+
+		remove(): this;
+
+		getLngLat(): mapboxgl.LngLat;
+
+		setLngLat(lnglat: mapboxgl.LngLat | number[]): this;
+
+		setText(text: string): this;
+
+		setHTML(html: string): this;
+
+		setDOMContent(htmlNode: Node): this;
+	}
+
+	export interface PopupOptions {
+		closeButton?: boolean;
+
+		closeOnClick?: boolean;
+
+		anchor?: 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+
+		offset?: number | Point | number[] | { [key:string]: Point | number[];};
+	}
+
+	export interface Style {
+		bearing?: number;
+		center?: number[];
+		glyphs?: string;
+		layers?: Layer[];
+		metadata?: any;
+		name?: string;
+		pitch?: number;
+		sources?: any;
+		sprite?: string;
+		transition?: Transition;
+		version: number;
+		zoom?: number;
+	}
+
+	export interface Transition {
+		delay?: number;
+		duration?: number;
+	}
+
+	export interface Source {
+		type: "vector" | "raster" | "geojson" | "image" | "video";
+	}
+
+	/**
+	 * GeoJSONSource
+	 */
+
+	export interface GeoJSONSourceRaw extends Source, GeoJSONSourceOptions {
+		type: "geojson";
+	}
+
+	export class GeoJSONSource implements GeoJSONSourceRaw {
+		type: "geojson";
+
+		constructor(options?: mapboxgl.GeoJSONSourceOptions);
+
+		setData(data: GeoJSON.Feature<GeoJSON.GeometryObject> | GeoJSON.FeatureCollection<GeoJSON.GeometryObject> | String): this;
+	}
+
+	export interface GeoJSONSourceOptions {
+		data?: GeoJSON.Feature<GeoJSON.GeometryObject> | GeoJSON.FeatureCollection<GeoJSON.GeometryObject> | string;
+
+		maxzoom?: number;
+
+		buffer?: number;
+
+		tolerance?: number;
+
+		cluster?: number | boolean;
+
+		clusterRadius?: number;
+
+		clusterMaxZoom?: number;
+	}
+
+	/**
+	 * VideoSource
+	 */
+	export class VideoSource implements Source, VideoSourceOptions {
+		type: "video";
+		
+		constructor(options?: mapboxgl.VideoSourceOptions);
+
+		getVideo(): HTMLVideoElement;
+
+		setCoordinates(coordinates: number[][]): this;
+	}
+
+	export interface VideoSourceOptions {
+		urls?: string[];
+
+		coordinates?: number[][];
+	}
+
+	/**
+	 * ImageSource
+	 */
+	export class ImageSource implements Source, ImageSourceOptions {
+		type: "image";
+
+		constructor(options?: mapboxgl.ImageSourceOptions);
+
+		setCoordinates(coordinates: number[][]): this;
+	}
+
+	export interface ImageSourceOptions {
+		url?: string;
+
+		coordinates?: number[][];
+	}
+
+	interface VectorSource extends Source {
+		type: "vector";
+		url?: string;
+		tiles?: string[];
+		minzoom?: number;
+		maxzoom?: number;
+	}
+
+	interface RasterSource extends Source {
+		type: "raster";
+		url: string;
+		tiles?: string[];
+		minzoom?: number;
+		maxzoom?: number;
+		tileSize?: number;
+	}
+
+	/**
+	 * LngLat
+	 */
+	export class LngLat {
+		lng: number;
+		lat: number;
+
+		constructor(lng: number, lat: number);
+
+		/** Return a new LngLat object whose longitude is wrapped to the range (-180, 180). */
+		wrap(): mapboxgl.LngLat;
+
+		/** Return a LngLat as an array */
+		toArray(): number[];
+
+		/** Return a LngLat as a string */
+		toString(): string;
+
+		static convert(input: number[]|mapboxgl.LngLat): mapboxgl.LngLat;
+	}
+
+	/**
+	 * LngLatBounds
+	 */
+	export class LngLatBounds {
+		sw: LngLat | number[];
+		ne: LngLat | number[];
+		constructor(sw?: LngLat, ne?: LngLat);
+
+		/** Extend the bounds to include a given LngLat or LngLatBounds. */
+		extend(obj: mapboxgl.LngLat | mapboxgl.LngLatBounds): this;
+
+		/** Get the point equidistant from this box's corners */
+		getCenter(): mapboxgl.LngLat;
+
+		/** Get southwest corner */
+		getSouthWest(): mapboxgl.LngLat;
+
+		/** Get northeast corner */
+		getNorthEast(): mapboxgl.LngLat;
+
+		/** Get northwest corner */
+		getNorthWest(): mapboxgl.LngLat;
+
+		/** Get southeast corner */
+		getSouthEast(): mapboxgl.LngLat;
+
+		/** Get west edge longitude */
+		getWest(): number;
+
+		/** Get south edge latitude */
+		getSouth(): number;
+
+		/** Get east edge longitude */
+		getEast(): number;
+
+		/** Get north edge latitude */
+		getNorth(): number;
+
+		/** Returns a LngLatBounds as an array */
+		toArray(): number[][];
+
+		/** Return a LngLatBounds as a string */
+		toString(): string;
+
+		/** Convert an array to a LngLatBounds object, or return an existing LngLatBounds object unchanged. */
+		static convert(input: mapboxgl.LngLatBounds | number[] | number[][]): mapboxgl.LngLatBounds;
+	}
+
+	/**
+	 * Point
+	 */
+		// Todo: Pull out class to seperate definition for Module "point-geometry"
+	export class Point {
+		constructor(options?: Object);
+
+		clone(): Point;
+
+		add(p: number): Point;
+
+		sub(p: number): Point;
+
+		mult(k: number): Point;
+
+		div(k: number): Point;
+
+		rotate(a: number): Point;
+
+		matMult(m: number): Point;
+
+		unit(): Point;
+
+		perp(): Point;
+
+		round(): Point;
+
+		mag(): number;
+
+		equals(): boolean;
+
+		dist(): number;
+
+		distSqr(): number;
+
+		angle(): number;
+
+		angleTo(): number;
+
+		angleWidth(): number;
+
+		angleWidthSep(): number;
+	}
+
+	export class Marker {
+		constructor(element?: HTMLElement, options?: { offset?: Point | number[] });
+
+		addTo(map: Map): this;
+
+		remove(): this;
+
+		getLngLat(): LngLat;
+
+		setLngLat(lngLat: LngLat | number[]): this;
+
+		setPopup(popup?: Popup): this;
+
+		getPopup(): Popup;
+
+		togglePopup(): this;
+	}
+
+	/**
+	 * Evented
+	 */
+	export class Evented {
+		on(type: string, listener: Function): this;
+
+		off(type?: string | any, listener?: Function): this;
+
+		once(type: string, listener: Function): this;
+
+		fire(type: string, data?: mapboxgl.EventData | Object): this;
+
+		listens(type: string): boolean;
+	}
+
+	/**
+	 * StyleOptions
+	 */
+	export interface StyleOptions {
+		transition?: boolean;
+	}
+
+	/**
+	 * EventData
+	 */
+	export class EventData {
+		type: string;
+		target: Map;
+		originalEvent: Event;
+		point: mapboxgl.Point;
+		lngLat: mapboxgl.LngLat;
+	}
+
+	export class MapMouseEvent {
+		type: string;
+		target: Map;
+		originalEvent: MouseEvent;
+		point: mapboxgl.Point;
+		lngLat: mapboxgl.LngLat;
+	}
+
+	export class MapTouchEvent {
+		type: string;
+		target: Map;
+		originalEvent: TouchEvent;
+		point: mapboxgl.Point;
+		lngLat: mapboxgl.LngLat;
+		points: Point[];
+		lngLats: LngLat[];
+	}
+
+	export class MapBoxZoomEvent {
+		originalEvent: MouseEvent;
+		boxZoomBounds: LngLatBounds;
+	}
+
+	/**
+	 * AnimationOptions
+	 */
+	export interface AnimationOptions {
+		/** Number in milliseconds */
+		duration?: number;
+		easing?: Function;
+		/** point, origin of movement relative to map center */
+		offset?: Point | number[];
+		/** When set to false, no animation happens */
+		animate?: boolean;
+	}
+
+	/**
+	 * CameraOptions
+	 */
+	export interface CameraOptions {
+		/** Map center */
+		center?: mapboxgl.LngLat | number[];
+		/** Map zoom level */
+		zoom?: number;
+		/** Map rotation bearing in degrees counter-clockwise from north */
+		bearing?: number;
+		/** Map angle in degrees at which the camera is looking at the ground */
+		pitch?: number;
+		/** If zooming, the zoom center (defaults to map center) */
+		around?: mapboxgl.LngLat | number[];
+	}
+
+	/**
+	 * FlyToOptions
+	 */
+	export interface FlyToOptions extends AnimationOptions, CameraOptions {
+		curve?: number;
+		minZoom?: number;
+		speed?: number;
+		screenSpeed?: number;
+		easing?: Function;
+	}
+
+	/**
+	 * MapEvent
+	 */
+	export interface MapEvent {
+		webglcontextlost?: {originalEvent: WebGLContextEvent};
+		webglcontextrestored?: {originalEvent: WebGLContextEvent};
+		render?: void;
+		contextmenu?: {data: mapboxgl.MapMouseEvent};
+		dblclick?: {data: mapboxgl.MapMouseEvent};
+		click?: {data: mapboxgl.MapMouseEvent};
+		touchcancel?: {data: mapboxgl.MapTouchEvent};
+		touchmove?: {data: mapboxgl.MapTouchEvent};
+		touchend?: {data: mapboxgl.MapTouchEvent};
+		touchstart?: {data: mapboxgl.MapTouchEvent};
+		mousemove?: {data: mapboxgl.MapMouseEvent};
+		mouseup?: {data: mapboxgl.MapMouseEvent};
+		mousedown?: {data: mapboxgl.MapMouseEvent};
+		moveend?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		move?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		movestart?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		mouseout?:{data: mapboxgl.MapMouseEvent};
+		load?: void;
+		zoomend?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		zoom?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		zoomstart?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		boxzoomcancel?: {data: mapboxgl.MapBoxZoomEvent};
+		boxzoomstart?: {data: mapboxgl.MapBoxZoomEvent};
+		boxzoomend?: {data: mapboxgl.MapBoxZoomEvent};
+		rotate?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		rotatestart?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		rotateend?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		drag?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		dragend?: {data: mapboxgl.MapMouseEvent | mapboxgl.MapTouchEvent};
+		pitch?: {data: mapboxgl.EventData};
+	}
+
+	export interface Layer {
+		id: string;
+		type?: "fill" | "line" | "symbol" | "circle" | "raster" | "background" | string; //TODO: Ideally we wouldn't accept string here, just these specific strings
+
+		metadata?: any;
+		ref?: string;
+
+		source?: string;
+
+		"source-layer"?: string;
+
+		minzoom?: number;
+		maxzoom?: number;
+
+		interactive?: boolean;
+
+		filter?: any[];
+		layout?: BackgroundLayout | FillLayout | LineLayout | SymbolLayout | RasterLayout | CircleLayout;
+		paint?: BackgroundPaint | FillPaint | LinePaint | SymbolPaint | RasterPaint | CirclePaint;
+	}
+
+	export interface StyleFunction {
+		stops: any[][];
+		property?: string;
+		base?: number;
+		type?: "continuous" | "interval" | "categorical";
+	}
+
+	export interface BackgroundLayout {
+		visibility?: "visible" | "none";
+	}
+	export interface BackgroundPaint {
+		"background-color"?: string;
+		"background-pattern"?: string;
+		"background-opacity"?: number;
+	}
+
+	export interface FillLayout {
+		visibility?: "visible" | "none";
+	}
+	export interface FillPaint {
+		"fill-antialias"?: boolean;
+		"fill-opacity"?: number | StyleFunction;
+		"fill-color"?: string | StyleFunction;
+		"fill-outline-color": string | StyleFunction;
+		"fill-translate"?: number[];
+		"fill-translate-anchor"?: "map" | "viewport";
+		"fill-pattern"?: "string";
+	}
+
+	export interface LineLayout {
+		visibility?: "visible" | "none";
+
+		"line-cap"?: "butt" | "round" | "square";
+		"line-join"?: "bevel" | "round" | "miter";
+		"line-miter-limit"?: number;
+		"line-round-limit"?: number;
+	}
+	export interface LinePaint {
+		"line-opacity"?: number;
+		"line-color"?: string| StyleFunction;
+		"line-translate"?: number[];
+		"line-translate-anchor"?: "map" | "viewport";
+		"line-width"?: number;
+		"line-gap-width"?: number;
+		"line-offset"?: number;
+		"line-blur"?: number;
+		"line-dasharray"?: number[];
+		"line-dasharray-transition"?: Transition;
+		"line-pattern"?: string;
+	}
+
+	export interface SymbolLayout {
+		visibility?: "visible" | "none";
+
+		"symbol-placement"?: "point" | "line";
+		"symbol-spacing"?: number;
+		"symbol-avoid-edges"?: boolean;
+		"icon-allow-overlap"?: boolean;
+		"icon-ignore-placement"?: boolean;
+		"icon-optional"?: boolean;
+		"icon-rotation-alignment"?: "map" | "viewport" | "auto";
+		"icon-size"?: number;
+		"icon-text-fit"?: "none" | "both" | "width" | "height";
+		"icon-text-fit-padding"?: number[];
+		"icon-image"?: string;
+		"icon-rotate"?: number | StyleFunction;
+		"icon-padding"?: number;
+		"icon-keep-upright"?: boolean;
+		"icon-offset"?: number[];
+		"text-pitch-alignment"?: "map" | "viewport" | "auto";
+		"text-rotation-alignment"?: "map" | "viewport" | "auto";
+		"text-field"?: string;
+		"text-font"?: string | string[];
+		"text-size"?: number;
+		"text-max-width"?: number;
+		"text-line-height"?: number;
+		"text-letter-spacing"?: number;
+		"text-justify"?: "left" | "center" | "right";
+		"text-anchor"?: "center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+		"text-max-angle"?: number;
+		"text-rotate"?: number;
+		"text-padding"?: number;
+		"text-keep-upright"?: boolean;
+		"text-transform"?: "none" | "uppercase" | "lowercase";
+		"text-offset"?: number[];
+		"text-allow-overlap"?: boolean;
+		"text-ignore-placement"?: boolean;
+		"text-optional"?: boolean;
+
+	}
+	export interface SymbolPaint {
+		"icon-opacity"?: number;
+		"icon-color"?: string;
+		"icon-halo-color"?: string;
+		"icon-halo-width"?: number;
+		"icon-halo-blur"?: number;
+		"icon-translate"?: number[];
+		"icon-translate-anchor"?: "map" | "viewport";
+		"text-opacity"?: number;
+		"text-color"?: "string";
+		"text-halo-color"?: "string";
+		"text-halo-width"?: number;
+		"text-halo-blur"?: number;
+		"text-translate"?: number[];
+		"text-translate-anchor"?: "map" | "viewport";
+	}
+
+	export interface RasterLayout {
+		visibility?: "visible" | "none";
+	}
+
+	export interface RasterPaint {
+		"raster-opacity"?: number;
+		"raster-hue-rotate"?: number;
+		"raster-brightness-min"?: number;
+		"raster-brightness-max"?: number;
+		"raster-saturation"?: number;
+		"raster-contrast"?: number;
+		"raster-fade-duration"?: number;
+	}
+
+	export interface CircleLayout {
+		visibility?: "visible" | "none";
+	}
+
+	export interface CirclePaint {
+		"circle-radius"?: number | StyleFunction;
+		"circle-radius-transition"?: Transition;
+		"circle-color"?: number | StyleFunction;
+		"circle-blur"?: number | StyleFunction;
+		"circle-opacity"?: number | StyleFunction;
+		"circle-translate"?: number[];
+		"circle-translate-anchor"?: "map" | "viewport";
+		"circle-pitch-scale"?: "map" | "viewport";
+	}
+}
+
+declare module 'mapbox-gl' {
+	export = mapboxgl;
+}

mocha/index.d.ts

@@ -42,6 +42,9 @@ declare var xit: Mocha.ITestDefinition;
 declare var test: Mocha.ITestDefinition;
 declare var specify: Mocha.ITestDefinition;
 
+// Used with the --delay flag; see https://mochajs.org/#hooks
+declare function run(): void;
+
 interface MochaDone {
     (error?: any): any;
 }

nes/nes.d.ts

@@ -61,7 +61,7 @@ declare module 'nes' {
         user?: any;
     }
 
-    export interface ServerEachSokcetOptions {
+    export interface ServerEachSocketOptions {
         subscription?: string;
         user?: any;
     }
@@ -70,7 +70,7 @@ declare module 'nes' {
         broadcast(message: any, options?: ServerBroadcastOptions): void;
         subscription(path: string, options?: ServerSubscriptionOptions): void;
         publish(path: string, message: any, options?: ServerPublishOptions): void;
-        eachSocket(each: (socket: Socket) => void, options?: ServerEachSokcetOptions): void;
+        eachSocket(each: (socket: Socket) => void, options?: ServerEachSocketOptions): void;
     }
 
     export class Request extends Hapi.Request {
@@ -82,7 +82,7 @@ declare module 'nes' {
         timeout?: number | boolean;
     }
 
-    export interface ClientConnnectOptions {
+    export interface ClientConnectOptions {
         auth?: any;
         delay?: number;
         maxDelay?: number;
@@ -107,7 +107,7 @@ declare module 'nes' {
         onConnect: () => void;
         onDisconnect: () => void;
         onUpdate: (message: any) => void;
-        connect(options: ClientConnnectOptions, callback: (err?: any) => void): void;
+        connect(options: ClientConnectOptions, callback: (err?: any) => void): void;
         connect(callback: (err?: any) => void): void;
         disconnect(): void;
         id: any;
@@ -123,7 +123,7 @@ declare module 'nes' {
 declare module 'nes/client' {
     export {
         Client,
-        ClientConnnectOptions,
+        ClientConnectOptions,
         ClientRequestOptions,
         ClientSubscribeFlags
     } from 'nes';

noble/index.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for noble
 // Project: https://github.com/sandeepmistry/noble
-// Definitions by: Seon-Wook Park <https://github.com/swook>, Hans Bakker <https://github.com/wind-rider>
+// Definitions by: Seon-Wook Park <https://github.com/swook>, Hans Bakker <https://github.com/wind-rider>, Shantanu Bhadoria <https://github.com/shantanubhadoria>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="node" />
@@ -20,11 +20,15 @@ export declare function on(event: "scanStop", listener: () => void): events.Even
 export declare function on(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
 
 export declare class Peripheral extends events.EventEmitter {
-    uuid: string;
+    id:            string;
+    uuid:          string;
+    address:       string;
+    addressType:   string;
+    connectable:   boolean;
     advertisement: Advertisement;
-    rssi: number;
-    services: Service[];
-    state: string;
+    rssi:          number;
+    services:      Service[];
+    state:         string;
 
     connect(callback?: (error: string) => void): void;
     disconnect(callback?: () => void): void;

node/index.d.ts

@@ -67,7 +67,7 @@ interface NodeRequire extends NodeRequireFunction {
     resolve(id: string): string;
     cache: any;
     extensions: any;
-    main: any;
+    main: NodeModule;
 }
 
 declare var require: NodeRequire;
@@ -78,8 +78,8 @@ interface NodeModule {
     id: string;
     filename: string;
     loaded: boolean;
-    parent: any;
-    children: any[];
+    parent: NodeModule;
+    children: NodeModule[];
 }
 
 declare var module: NodeModule;
@@ -253,7 +253,7 @@ declare namespace NodeJS {
     }
 
     export interface ErrnoException extends Error {
-        errno?: string;
+        errno?: number;
         code?: string;
         path?: string;
         syscall?: string;
@@ -392,6 +392,7 @@ declare namespace NodeJS {
         title: string;
         arch: string;
         platform: string;
+        mainModule?: NodeModule;
         memoryUsage(): MemoryUsage;
         nextTick(callback: Function, ...args: any[]): void;
         umask(mask?: number): number;
@@ -1342,7 +1343,37 @@ declare module "repl" {
 
     export interface REPLServer extends readline.ReadLine {
         defineCommand(keyword: string, cmd: Function | { help: string, action: Function }): void;
-        displayPrompt(preserveCursor?: boolean): void
+        displayPrompt(preserveCursor?: boolean): void;
+
+        /**
+         * events.EventEmitter
+         * 1. exit
+         * 2. reset
+         **/
+
+        addListener(event: string, listener: Function): this;
+        addListener(event: "exit", listener: () => void): this;
+        addListener(event: "reset", listener: Function): this;
+
+        emit(event: string, ...args: any[]): boolean;
+        emit(event: "exit"): boolean;
+        emit(event: "reset", context: any): boolean;
+
+        on(event: string, listener: Function): this;
+        on(event: "exit", listener: () => void): this;
+        on(event: "reset", listener: Function): this;
+
+        once(event: string, listener: Function): this;
+        once(event: "exit", listener: () => void): this;
+        once(event: "reset", listener: Function): this;
+
+        prependListener(event: string, listener: Function): this;
+        prependListener(event: "exit", listener: () => void): this;
+        prependListener(event: "reset", listener: Function): this;
+
+        prependOnceListener(event: string, listener: Function): this;
+        prependOnceListener(event: "exit", listener: () => void): this;
+        prependOnceListener(event: "reset", listener: Function): this;
     }
 
     export function start(options: ReplOptions): REPLServer;
@@ -1368,6 +1399,71 @@ declare module "readline" {
         resume(): ReadLine;
         close(): void;
         write(data: string | Buffer, key?: Key): void;
+
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. line
+         * 3. pause
+         * 4. resume
+         * 5. SIGCONT
+         * 6. SIGINT
+         * 7. SIGTSTP
+         **/
+
+        addListener(event: string, listener: Function): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "line", listener: (input: any) => void): this;
+        addListener(event: "pause", listener: () => void): this;
+        addListener(event: "resume", listener: () => void): this;
+        addListener(event: "SIGCONT", listener: () => void): this;
+        addListener(event: "SIGINT", listener: () => void): this;
+        addListener(event: "SIGTSTP", listener: () => void): this;
+
+        emit(event: string, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "line", input: any): boolean;
+        emit(event: "pause"): boolean;
+        emit(event: "resume"): boolean;
+        emit(event: "SIGCONT"): boolean;
+        emit(event: "SIGINT"): boolean;
+        emit(event: "SIGTSTP"): boolean;
+
+        on(event: string, listener: Function): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "line", listener: (input: any) => void): this;
+        on(event: "pause", listener: () => void): this;
+        on(event: "resume", listener: () => void): this;
+        on(event: "SIGCONT", listener: () => void): this;
+        on(event: "SIGINT", listener: () => void): this;
+        on(event: "SIGTSTP", listener: () => void): this;
+
+        once(event: string, listener: Function): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "line", listener: (input: any) => void): this;
+        once(event: "pause", listener: () => void): this;
+        once(event: "resume", listener: () => void): this;
+        once(event: "SIGCONT", listener: () => void): this;
+        once(event: "SIGINT", listener: () => void): this;
+        once(event: "SIGTSTP", listener: () => void): this;
+
+        prependListener(event: string, listener: Function): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "line", listener: (input: any) => void): this;
+        prependListener(event: "pause", listener: () => void): this;
+        prependListener(event: "resume", listener: () => void): this;
+        prependListener(event: "SIGCONT", listener: () => void): this;
+        prependListener(event: "SIGINT", listener: () => void): this;
+        prependListener(event: "SIGTSTP", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: Function): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "line", listener: (input: any) => void): this;
+        prependOnceListener(event: "pause", listener: () => void): this;
+        prependOnceListener(event: "resume", listener: () => void): this;
+        prependOnceListener(event: "SIGCONT", listener: () => void): this;
+        prependOnceListener(event: "SIGINT", listener: () => void): this;
+        prependOnceListener(event: "SIGTSTP", listener: () => void): this;
     }
 
     export interface Completer {
@@ -1429,6 +1525,7 @@ declare module "vm" {
 declare module "child_process" {
     import * as events from "events";
     import * as stream from "stream";
+    import * as net from "net";
 
     export interface ChildProcess extends events.EventEmitter {
         stdin: stream.Writable;
@@ -1442,6 +1539,57 @@ declare module "child_process" {
         disconnect(): void;
         unref(): void;
         ref(): void;
+    
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. disconnet
+         * 3. error
+         * 4. exit
+         * 5. message
+         **/
+
+        addListener(event: string, listener: Function): this;
+        addListener(event: "close", listener: (code: number, signal: string) => void): this;
+        addListener(event: "disconnet", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "exit", listener: (code: number, signal: string) => void): this;
+        addListener(event: "message", listener: (message: any, sendHandle: net.Socket | net.Server) => void): this;
+
+        emit(event: string, ...args: any[]): boolean;
+        emit(event: "close", code: number, signal: string): boolean;
+        emit(event: "disconnet"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "exit", code: number, signal: string): boolean;
+        emit(event: "message", message: any, sendHandle: net.Socket | net.Server): boolean;
+
+        on(event: string, listener: Function): this;
+        on(event: "close", listener: (code: number, signal: string) => void): this;
+        on(event: "disconnet", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "exit", listener: (code: number, signal: string) => void): this;
+        on(event: "message", listener: (message: any, sendHandle: net.Socket | net.Server) => void): this;
+
+        once(event: string, listener: Function): this;
+        once(event: "close", listener: (code: number, signal: string) => void): this;
+        once(event: "disconnet", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "exit", listener: (code: number, signal: string) => void): this;
+        once(event: "message", listener: (message: any, sendHandle: net.Socket | net.Server) => void): this;
+
+        prependListener(event: string, listener: Function): this;
+        prependListener(event: "close", listener: (code: number, signal: string) => void): this;
+        prependListener(event: "disconnet", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "exit", listener: (code: number, signal: string) => void): this;
+        prependListener(event: "message", listener: (message: any, sendHandle: net.Socket | net.Server) => void): this;
+
+        prependOnceListener(event: string, listener: Function): this;
+        prependOnceListener(event: "close", listener: (code: number, signal: string) => void): this;
+        prependOnceListener(event: "disconnet", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "exit", listener: (code: number, signal: string) => void): this;
+        prependOnceListener(event: "message", listener: (message: any, sendHandle: net.Socket | net.Server) => void): this;
     }
 
     export interface SpawnOptions {
@@ -1802,9 +1950,9 @@ declare module "net" {
         listen(port: number, listeningListener?: Function): Server;
         listen(path: string, backlog?: number, listeningListener?: Function): Server;
         listen(path: string, listeningListener?: Function): Server;
+        listen(options: ListenOptions, listeningListener?: Function): Server;
         listen(handle: any, backlog?: number, listeningListener?: Function): Server;
         listen(handle: any, listeningListener?: Function): Server;
-        listen(options: ListenOptions, listeningListener?: Function): Server;
         close(callback?: Function): Server;
         address(): { port: number; family: string; address: string; };
         getConnections(cb: (error: Error, count: number) => void): void;

node/node-4-tests.ts

@@ -24,6 +24,19 @@ import * as string_decoder from "string_decoder";
 // Specifically test buffer module regression.
 import {Buffer as ImportedBuffer, SlowBuffer as ImportedSlowBuffer} from "buffer";
 
+//////////////////////////////////////////////////////////
+/// Global Tests : https://nodejs.org/api/global.html  ///
+//////////////////////////////////////////////////////////
+namespace global_tests {
+    {
+        let x: NodeModule;
+        let y: NodeModule;
+        x.children.push(y);
+        x.parent = require.main;
+        require.main = y;
+    }
+}
+
 //////////////////////////////////////////////////////////
 /// Assert Tests : https://nodejs.org/api/assert.html ///
 //////////////////////////////////////////////////////////
@@ -928,6 +941,10 @@ namespace process_tests {
         var _p: NodeJS.Process = process;
         _p = p;
     }
+    {
+        var module: NodeModule;
+        module = process.mainModule;
+    }
 }
 
 ///////////////////////////////////////////////////////////

node/node-4.d.ts

@@ -52,7 +52,7 @@ interface NodeRequire extends NodeRequireFunction {
     resolve(id:string): string;
     cache: any;
     extensions: any;
-    main: any;
+    main: NodeModule;
 }
 
 declare var require: NodeRequire;
@@ -63,8 +63,8 @@ interface NodeModule {
     id: string;
     filename: string;
     loaded: boolean;
-    parent: any;
-    children: any[];
+    parent: NodeModule;
+    children: NodeModule[];
 }
 
 declare var module: NodeModule;
@@ -339,6 +339,7 @@ declare namespace NodeJS {
         title: string;
         arch: string;
         platform: string;
+        mainModule?: NodeModule;
         memoryUsage(): MemoryUsage;
         nextTick(callback: Function): void;
         umask(mask?: number): number;

node/node-tests.ts

@@ -22,10 +22,24 @@ import * as console2 from "console";
 import * as string_decoder from "string_decoder";
 import * as stream from "stream";
 import * as timers from "timers";
+import * as repl from "repl";
 
 // Specifically test buffer module regression.
 import {Buffer as ImportedBuffer, SlowBuffer as ImportedSlowBuffer} from "buffer";
 
+//////////////////////////////////////////////////////////
+/// Global Tests : https://nodejs.org/api/global.html  ///
+//////////////////////////////////////////////////////////
+namespace global_tests {
+    {
+        let x: NodeModule;
+        let y: NodeModule;
+        x.children.push(y);
+        x.parent = require.main;
+        require.main = y;
+    }
+}
+
 //////////////////////////////////////////////////////////
 /// Assert Tests : https://nodejs.org/api/assert.html ///
 //////////////////////////////////////////////////////////
@@ -165,7 +179,7 @@ namespace fs_tests {
     }
     
     {
-        var errno: string;
+        var errno: number;
         fs.readFile('testfile', (err, data) => {
             if (err && err.errno) {
                 errno = err.errno;
@@ -1206,6 +1220,69 @@ namespace readline_tests {
 
         readline.clearScreenDown(stream);
     }
+
+    {
+        let _rl: readline.ReadLine;
+        let _boolean: boolean;
+
+        _rl = _rl.addListener("close", () => { });
+        _rl = _rl.addListener("line", (input) => {
+            let _input: any = input;
+        })
+        _rl = _rl.addListener("pause", () => { });
+        _rl = _rl.addListener("resume", () => { });
+        _rl = _rl.addListener("SIGCONT", () => { });
+        _rl = _rl.addListener("SIGINT", () => { });
+        _rl = _rl.addListener("SIGTSTP", () => { });
+
+        _boolean = _rl.emit("close", () => { });
+        _boolean = _rl.emit("line", () => { });
+        _boolean = _rl.emit("pause", () => { });
+        _boolean = _rl.emit("resume", () => { });
+        _boolean = _rl.emit("SIGCONT", () => { });
+        _boolean = _rl.emit("SIGINT", () => { });
+        _boolean = _rl.emit("SIGTSTP", () => { });
+
+        _rl = _rl.on("close", () => { });
+        _rl = _rl.on("line", (input) => {
+            let _input: any = input;
+        })
+        _rl = _rl.on("pause", () => { });
+        _rl = _rl.on("resume", () => { });
+        _rl = _rl.on("SIGCONT", () => { });
+        _rl = _rl.on("SIGINT", () => { });
+        _rl = _rl.on("SIGTSTP", () => { });
+
+        _rl = _rl.once("close", () => { });
+        _rl = _rl.once("line", (input) => {
+            let _input: any = input;
+        })
+        _rl = _rl.once("pause", () => { });
+        _rl = _rl.once("resume", () => { });
+        _rl = _rl.once("SIGCONT", () => { });
+        _rl = _rl.once("SIGINT", () => { });
+        _rl = _rl.once("SIGTSTP", () => { });
+
+        _rl = _rl.prependListener("close", () => { });
+        _rl = _rl.prependListener("line", (input) => {
+            let _input: any = input;
+        })
+        _rl = _rl.prependListener("pause", () => { });
+        _rl = _rl.prependListener("resume", () => { });
+        _rl = _rl.prependListener("SIGCONT", () => { });
+        _rl = _rl.prependListener("SIGINT", () => { });
+        _rl = _rl.prependListener("SIGTSTP", () => { });
+
+        _rl = _rl.prependOnceListener("close", () => { });
+        _rl = _rl.prependOnceListener("line", (input) => {
+            let _input: any = input;
+        })
+        _rl = _rl.prependOnceListener("pause", () => { });
+        _rl = _rl.prependOnceListener("resume", () => { });
+        _rl = _rl.prependOnceListener("SIGCONT", () => { });
+        _rl = _rl.prependOnceListener("SIGINT", () => { });
+        _rl = _rl.prependOnceListener("SIGTSTP", () => { });
+    }
 }
 
 ////////////////////////////////////////////////////
@@ -1232,6 +1309,102 @@ namespace child_process_tests {
         childProcess.exec("echo test");
         childProcess.spawnSync("echo test");    
     }
+    
+    {
+        let _cp: childProcess.ChildProcess;
+        let _boolean: boolean;
+
+        _cp = _cp.addListener("close", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.addListener("disconnet", () => { });
+        _cp = _cp.addListener("error", (err) => {
+            let _err: Error = err;
+        })
+        _cp = _cp.addListener("exit", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.addListener("message", (message, sendHandle) => {
+            let _message: any = message;
+            let _sendHandle: net.Socket | net.Server = sendHandle;
+        })
+
+        _boolean = _cp.emit("close", () => { });
+        _boolean = _cp.emit("disconnet", () => { });
+        _boolean = _cp.emit("error", () => { });
+        _boolean = _cp.emit("exit", () => { });
+        _boolean = _cp.emit("message", () => { });
+
+        _cp = _cp.on("close", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.on("disconnet", () => { });
+        _cp = _cp.on("error", (err) => {
+            let _err: Error = err;
+        })
+        _cp = _cp.on("exit", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.on("message", (message, sendHandle) => {
+            let _message: any = message;
+            let _sendHandle: net.Socket | net.Server = sendHandle;
+        })
+
+        _cp = _cp.once("close", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.once("disconnet", () => { });
+        _cp = _cp.once("error", (err) => {
+            let _err: Error = err;
+        })
+        _cp = _cp.once("exit", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.once("message", (message, sendHandle) => {
+            let _message: any = message;
+            let _sendHandle: net.Socket | net.Server = sendHandle;
+        })
+
+        _cp = _cp.prependListener("close", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.prependListener("disconnet", () => { });
+        _cp = _cp.prependListener("error", (err) => {
+            let _err: Error = err;
+        })
+        _cp = _cp.prependListener("exit", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.prependListener("message", (message, sendHandle) => {
+            let _message: any = message;
+            let _sendHandle: net.Socket | net.Server = sendHandle;
+        })
+
+        _cp = _cp.prependOnceListener("close", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.prependOnceListener("disconnet", () => { });
+        _cp = _cp.prependOnceListener("error", (err) => {
+            let _err: Error = err;
+        })
+        _cp = _cp.prependOnceListener("exit", (code, signal) => {
+            let _code: number = code;
+            let _signal: string = signal;
+        })
+        _cp = _cp.prependOnceListener("message", (message, sendHandle) => {
+            let _message: any = message;
+            let _sendHandle: net.Socket | net.Server = sendHandle;
+        })
+    }
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -1400,6 +1573,10 @@ namespace process_tests {
     {
         assert(process.argv[0] === process.argv0);
     }
+    {
+        var module: NodeModule;
+        module = process.mainModule;
+    }
 }
 
 ///////////////////////////////////////////////////////////
@@ -1651,6 +1828,36 @@ namespace net_tests {
 
 }
 
+/////////////////////////////////////////////////////
+/// repl Tests : https://nodejs.org/api/repl.html ///
+/////////////////////////////////////////////////////
+
+namespace repl_tests {
+    {
+        let _server: repl.REPLServer;
+        let _boolean: boolean;
+        let _ctx: any;
+
+        _server = _server.addListener("exit", () => { });
+        _server = _server.addListener("reset", () => { });
+
+        _boolean = _server.emit("exit", () => { });
+        _boolean = _server.emit("reset", _ctx);
+
+        _server = _server.on("exit", () => { });
+        _server = _server.on("reset", () => { });
+
+        _server = _server.once("exit", () => { });
+        _server = _server.once("reset", () => { });
+
+        _server = _server.prependListener("exit", () => { });
+        _server = _server.prependListener("reset", () => { });
+
+        _server = _server.prependOnceListener("exit", () => { });
+        _server = _server.prependOnceListener("reset", () => { });
+    }
+}
+
 /*****************************************************************************
  *                                                                           *
  * The following tests are the modules not mentioned in document but existed *