Merge remote-tracking branch 'upstream/types-2.0' 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"
+    ]
+}

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

koa/index.d.ts

@@ -159,6 +159,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 {

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;
@@ -1214,6 +1228,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", () => { });
+    }
 }
 
 ////////////////////////////////////////////////////
@@ -1240,6 +1317,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;
+        })
+    }
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -1408,6 +1581,10 @@ namespace process_tests {
     {
         assert(process.argv[0] === process.argv0);
     }
+    {
+        var module: NodeModule;
+        module = process.mainModule;
+    }
 }
 
 ///////////////////////////////////////////////////////////
@@ -1659,6 +1836,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 *

openui5/index.d.ts

@@ -0,0 +1,8 @@
+// Type definitions for OpenUI5 1.40
+// Project: http://openui5.org/
+// Definitions by: Lukas May <https://www.dscsag.com/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="./sap.m.d.ts" />
+/// <reference path="./sap.ui.d.ts" />
+/// <reference path="./jquery.sap.d.ts" />

openui5/jquery.sap.d.ts

@@ -0,0 +1,187 @@
+// Type definitions for OpenUI5 1.40
+// Project: http://openui5.org/
+// Definitions by: Lukas May <https://www.dscsag.com/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped 
+
+/// <reference types="jquery" />
+
+declare interface Ui5Logger {
+  //Allows to add a new LogListener that will be notified for new log entries.
+  addLogListener(oListener: any): void;
+  //Creates a new debug-level entry in the log with the given message, details and calling component.
+  debug(sMessage: string, sDetails?: string, sComponent?: string): void;
+  //Creates a new error-level entry in the log with the given message, details and calling component.
+  error(sMessage: string, sDetails?: string, sComponent?: string): void;
+  //Creates a new fatal-level entry in the log with the given message, details and calling component.
+  fatal(sMessage: string, sDetails?: string, sComponent?: string): void;
+  //Returns the log level currently effective for the given component.
+  getLevel(sComponent?: string): void;
+  //Returns the logged entries recorded so far as an array.
+  getLogEntries(): void;
+  //Returns a jQuery.sap.log.Logger for the given component.
+  getLogger(sComponent: string, iDefaultLogLevel?: any): void;
+  //Creates a new info-level entry in the log with the given message, details and calling component.
+  info(sMessage: string, sDetails?: string, sComponent?: string): void;
+  //Checks whether logging is enabled for the given log level, depending on the currently effective log level for the given component.
+  isLoggable(iLevel?: any, sComponent?: string): void;
+  //Allows to remove a registered LogListener.
+  removeLogListener(oListener: any): void;
+  //Defines the maximum jQuery.sap.log.Level of log entries that will be recorded.
+  setLevel(iLogLevel: any, sComponent?: string): void;
+  //Creates a new trace-level entry in the log with the given message, details and calling component.
+  trace(sMessage: string, sDetails?: string, sComponent?: string): void;
+  //Creates a new warning-level entry in the log with the given message, details and calling component.
+  warning(sMessage: string, sDetails?: string, sComponent?: string): void;
+}
+declare interface JquerySap {
+  log: Ui5Logger
+  // Adds a whitelist entry for URL valiadtion 
+  addUrlWhitelist(protocol: any, host: any, port: any, path: any): void;
+  // Calculate delta of old list and new list This implements the algorithm described in "A Technique for Isolating Differences Between Files" (Commun. 
+  arrayDiff(aOld: any, aNew: any, fnCompare?: any, bUniqueEntries?: any): void;
+  // A simple assertion mechanism that logs a message when a given condition is not met. 
+  assert(bResult: any, sMessage: any): void;
+  // Binds all events for listening with the given callback function. 
+  bindAnyEvent(fnCallback: any): void;
+  // Shortcut for jQuery("#" + id) with additionally the id being escaped properly. 
+  byId(sId: any, oContext: any): void;
+  // Transforms a hyphen separated string to an camel case string. 
+  camelCase(sString: any): void;
+  // Converts a character of the string to upper case. 
+  charToUpperCase(sString: any, iPos: any): void;
+  // Checks a given mouseover or mouseout event whether it is equivalent to a mouseenter or mousleave event regarding the given DOM reference. 
+  checkMouseEnterOrLeave(oEvent: any, oDomRef: any): void;
+  // Stops the delayed call. 
+  clearDelayedCall(sDelayedCallId: any): void;
+  // Stops the interval call. 
+  clearIntervalCall(sIntervalCallId: any): void;
+  // clears the whitelist for URL valiadtion 
+  clearUrlWhitelist(): void;
+  // Returns whether oDomRefChild is oDomRefContainer or is contained in oDomRefContainer. 
+  containsOrEquals(oDomRefContainer: any, oDomRefChild: any): void;
+  // Declares a module as existing. 
+  declare(sModuleName: any, bCreateNamespace?: any): void;
+  // Calls a method after a given delay and returns an id for this timer 
+  delayedCall(iDelay: any, oObject: any, method: any, aParameters?: any): void;
+  // For the given scroll position measured from the "beginning" of a container (the right edge in RTL mode) this method returns the scrollLeft value as understood by the current browser in RTL mode. 
+  denormalizeScrollBeginRTL(iNormalizedScrollBegin: any, oDomRef: any): void;
+  // For the given scrollLeft value this method returns the scrollLeft value as understood by the current browser in RTL mode. 
+  denormalizeScrollLeftRTL(iNormalizedScrollLeft: any, oDomRef: any): void;
+  // Disable touch to mouse handling 
+  disableTouchToMouseHandling(): void;
+  // Shortcut for document.getElementById(), including a bug fix for older IE versions. 
+  domById(sId: any, oWindow?: any): void;
+  // Encode the string for inclusion into CSS string literals or identifiers 
+  encodeCSS(sString: any): void;
+  // Encode the string for inclusion into HTML content/attribute 
+  encodeHTML(sString: any): void;
+  // Encode the string for inclusion into a JS string literal 
+  encodeJS(sString: any): void;
+  // Encode the string for inclusion into an URL parameter 
+  encodeURL(sString: any): void;
+  // Encode a map of parameters into a combined URL parameter string 
+  encodeURLParameters(mParams: any): void;
+  // Encode the string for inclusion into XML content/attribute 
+  encodeXML(sString: any): void;
+  // Checks whether a given sString ends with sEndString respecting the case of the strings. 
+  endsWith(sString: any, sEndString: any): void;
+  // Checks whether a given sString ends with sEndString ignoring the case of the strings. 
+  endsWithIgnoreCase(sString: any, sEndString: any): void;
+  // Compares the two given values for equality, especially takes care not to compare arrays and objects by reference: any, but compares their content. 
+  equal(a: any, b: any, maxDepth?: any, contains?: any): void;
+  // This function escapes the reserved letters in Regular Expression 
+  escapeRegExp(sString: any): void;
+  // Returns a new constructor function that creates objects with the given prototype. 
+  factory(oPrototype: any): void;
+  // Calls focus() on the given DOM element, but catches and ignores any errors that occur when doing so. 
+  focus(oDomRef: any): void;
+  // Creates a string from a pattern by replacing placeholders with concrete values. 
+  formatMessage(sPattern: any, aValues?: any): void;
+  // Returns the names of all declared modules. 
+  getAllDeclaredModules(): void;
+  // Constructs an URL to load the module with the given name and file type (suffix). 
+  getModulePath(sModuleName: any, sSuffix: any): void;
+  // Returns a JavaScript object which is identified by a sequence of names. 
+  getObject(sName: any, iNoCreates?: any, oContext?: any): void;
+  // Determines the URL for a resource given its unified resource name. 
+  getResourcePath(sResourceName: any): void;
+  // Returns a new function that returns the given oValue (using its closure). 
+  getter(oValue: any): void;
+  // Creates and returns a new instance of jQuery.sap.util.UriParameters. 
+  getUriParameters(sUri: any): void;
+  // Gets the whitelist for URL valiadtion 
+  getUrlWhitelist(): void;
+  // Executes an 'eval' for its arguments in the global context (without closure variables). 
+  globalEval(): void;
+  // Transforms a camel case string into a hyphen separated string. 
+  hyphen(sString: any): void;
+  // Includes the script (via <script>-tag) into the head for the specified sUrl and optional sId. 
+  includeScript(sUrl: any, sId?: any, fnLoadCallback?: any, fnErrorCallback?: any): void;
+  // Includes the specified stylesheet via a <link>-tag in the head of the current document. 
+  includeStyleSheet(sUrl: any, sId?: any, fnLoadCallback?: any, fnErrorCallback?: any): void;
+  // Does some basic modifications to the HTML page that make it more suitable for mobile apps. 
+  initMobile(options?: any): void;
+  // Calls a method after a given interval and returns an id for this interval. 
+  intervalCall(iInterval: any, oObject: any, method: any, aParameters?: any): void;
+  // Check whether a given module has been loaded / declared already. 
+  isDeclared(sModuleName: any, bIncludePreloaded?: any): void;
+  // Returns a new object which has the given oPrototype as its prototype. 
+  newObject(oPrototype: any): void;
+  // Returns the window reference for a DomRef 
+  ownerWindow(oDomRef: any): void;
+  // Pads a string on the left side until is has the given length. 
+  padLeft(sString: any, sPadChar: any, iLength: any): void;
+  // Pads a string on the right side until is has the given length. 
+  padRight(sString: any, sPadChar: any, iLength: any): void;
+  // Parses the specified XML formatted string text using native parsing function of the browser and returns a valid XML document. 
+  parseXML(sXMLText: any): void;
+  // Creates and returns a new instance of jQuery.sap.util.Properties. 
+  properties(mParams?: any): void;
+  // Registers an URL prefix for a module name prefix. 
+  registerModulePath(sModuleName: any, vUrlPrefix: any): void;
+  // Registers an URL prefix for a resource name prefix. 
+  registerResourcePath(sResourceNamePrefix: any, vUrlPrefix: any): void;
+  // Removes a whitelist entry for URL valiadtion 
+  removeUrlWhitelist(iIndex: any): void;
+  // Ensures that the given module is loaded and executed before execution of the current script continues. 
+  require(vModuleName: any): void;
+  // Creates and returns a new instance of jQuery.sap.util.ResourceBundle using the given URL and locale to determine what to load. 
+  resources(mParams?: any): void;
+  // Returns the size (width of the vertical / height of the horizontal) native browser scrollbars. 
+  scrollbarSize(sClasses?: any, bForce?: any): void;
+  // Serializes the specified XML document into a string representation. 
+  serializeXML(oXMLDocument: any): void;
+  // Sets the bookmark icon for desktop browsers and the icon to be displayed on the home screen of iOS devices after the user does "add to home screen". 
+  setIcons(oIcons: any): void;
+  // Sets the "apple-mobile-web-app-capable" and "mobile-web-app-capable" meta information which defines whether the application is loaded in full screen mode (browser address bar and toolbar are hidden) after the user does "add to home screen" on mobile devices. 
+  setMobileWebAppCapable(bValue: any): void;
+  // Sets an object property to a given value, where the property is identified by a sequence of names (path: any). 
+  setObject(sName: any, vValue: any, oContext?: any): void;
+  // Convenience wrapper around jQuery.ajax() that avoids the need for callback functions when synchronous calls are made. 
+  sjax(oOrigSettings: any): void;
+  // Checks whether a given sString starts with sStartString respecting the case of the strings. 
+  startsWith(sString: any, sStartString: any): void;
+  // Checks whether a given sString starts with sStartString ignoring the case of the strings. 
+  startsWithIgnoreCase(sString: any, sStartString: any): void;
+  // Convenience wrapper for jQuery.sap.sjax that enforeces the Http method GET and defaults the data type of the result to 'text'. 
+  syncGet(sUrl: any, data: any, sDataType?: any): void;
+  // Convenience wrapper for jQuery.sap.sjax that enforces the Http method GET and the data type 'json'. 
+  syncGetJSON(sUrl: any, data: any, fallback?: any): void;
+  // Convenience wrapper for jQuery.sap.sjax that enforces the Http method GET and the data type 'text'. 
+  syncGetText(sUrl: any, data: any, fallback?: any): void;
+  // Convenience wrapper for jQuery.sap.sjax that enforces the Http method POST and defaults the data type of the result to 'text'. 
+  syncPost(sUrl: any, data: any, sDataType?: any): void;
+  // Search ancestors of the given source DOM element for the specified CSS class name. 
+  syncStyleClass(sStyleClass: any, vSource: any, vDestination: any): void;
+  // Creates and returns a pseudo-unique id. 
+  uid(): void;
+  // Unbinds all events for listening with the given callback function. 
+  unbindAnyEvent(fnCallback: any): void;
+  // Sorts the given array in-place and removes any duplicates (identified by "==="). 
+  unique(a: any): void;
+  // Validates an URL. 
+  validateUrl(sUrl: any): void;
+}
+declare interface JQueryStatic {
+  sap: JquerySap
+}

openui5/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "jquery.sap.d.ts",
+        "sap.m.d.ts",
+        "sap.ui.d.ts",
+        "ui5-tests.ts"
+    ]
+}