Merge branch 'master' into types-2.0

# Conflicts:
#	.gitignore
#	ajv/ajv.d.ts
#	angular-material/angular-material.d.ts
#	angular-protractor/angular-protractor.d.ts
#	angularjs/angular-tests.ts
#	angularjs/angular.d.ts
#	aws-sdk/aws-sdk.d.ts
#	electron-devtools-installer/electron-devtools-installer-tests.ts
#	electron-json-storage/electron-json-storage-tests.ts
#	electron-notifications/electron-notifications.d.ts
#	electron-notify/electron-notify.d.ts
#	electron-window-state/electron-window-state.d.ts
#	electron/electron-prebuilt.d.ts
#	enzyme/enzyme.d.ts
#	eventemitter3/eventemitter3-tests.ts
#	eventemitter3/eventemitter3.d.ts
#	graphql/graphql.d.ts
#	highcharts/highcharts.d.ts
#	immutable/immutable.d.ts
#	inquirer/inquirer.d.ts
#	jasmine/jasmine.d.ts
#	joi/joi.d.ts
#	jquery.dataTables/jquery.dataTables-tests.ts
#	jquery.dataTables/jquery.dataTables.d.ts
#	kafka-node/kafka-node.d.ts
#	kefir/kefir.d.ts
#	kendo-ui/kendo-ui.d.ts
#	koa/koa.d.ts
#	leaflet/leaflet.d.ts
#	lodash/lodash.d.ts
#	mapbox-gl/mapbox-gl.d.ts
#	material-ui/material-ui.d.ts
#	menubar/menubar.d.ts
#	mongodb/mongodb.d.ts
#	needle/needle-tests.ts
#	needle/needle.d.ts
#	noble/noble.d.ts
#	node/node.d.ts
#	pegjs/pegjs.d.ts
#	pixi.js/pixi.js.d.ts
#	polymer/polymer.d.ts
#	quill/quill-tests.ts
#	quill/quill.d.ts
#	react-bootstrap/react-bootstrap.d.ts
#	react-fa/react-fa-tests.tsx
#	react-fa/react-fa.d.ts
#	react-native/react-native.d.ts
#	react-select/react-select.d.ts
#	react/react.d.ts
#	threejs/three-vrcontrols.d.ts
#	threejs/three-vreffect.d.ts
#	toastr/toastr.d.ts
#	validator/validator.d.ts
#	webpack/webpack.d.ts
#	winston/winston.d.ts

.gitignore

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

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.

async/async-tests.ts

@@ -439,3 +439,357 @@ async.dir(function (name, callback) {
         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(null, 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(null, 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(null, 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(null, 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(null, 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(null, 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(null, 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(null, [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(null, 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(null, 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(null, 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)[];
 

automapper-ts/automapper-ts.d.ts

@@ -0,0 +1,559 @@
+// Type definitions for automapper-ts
+// Project: https://github.com/loedeman/AutoMapper
+// Definitions by: Bert Loedeman <https://github.com/loedeman>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module AutoMapperJs {
+    /**
+     * AutoMapper implementation, for both creating maps and performing maps. Comparable usage and functionality to the original
+     * .NET AutoMapper library is the pursuit of this implementation.
+     */
+    class AutoMapper {
+        /**
+         * Initializes the mapper with the supplied configuration.
+         * @param {(config: IConfiguration) => void} Configuration function to call.
+         */
+        initialize(configFunction: (config: IConfiguration) => void): void;
+
+        /**
+         * Create a createMap curry function which expects only a destination key.
+         * @param {string} sourceKey The map source key.
+         * @returns {(destinationKey: string) => ICreateMapFluentFunctions}
+         */
+        createMap(sourceKey: string | (new() => any)): (destinationKey: string | (new() => any)) => ICreateMapFluentFunctions;
+
+        /**
+         * Create a mapping profile.
+         * @param {string} sourceKey The map source key.
+         * @param {string} destinationKey The map destination key.
+         * @returns {Core.ICreateMapFluentFunctions}
+         */
+        createMap(sourceKey: string | (new() => any), destinationKey: string | (new() => any)): ICreateMapFluentFunctions;
+
+        /**
+         * Create a map curry function which expects a destination key and a source object.
+         * @param sourceKey Source key, for instance the source type name.
+         * @returns {(destinationKey: string, sourceObject: any) => any}
+         */
+        map(sourceKey: string | (new() => any)): (destinationKey: string | (new() => any), sourceObject: any) => any;
+
+        /**
+         * Create a map curry function which expects only a source object.
+         * @param sourceKey Source key, for instance the source type name.
+         * @param destinationKey Destination key, for instance the destination type name.
+         * @returns {(sourceObject: any) => any}
+         */
+        map(sourceKey: string | (new() => any), destinationKey: string | (new() => any)): (sourceObject: any) => any;
+
+        /**
+         * Execute a mapping from the source object to a new destination object with explicit mapping configuration and supplied mapping options (using createMap).
+         * @param sourceKey Source key, for instance the source type name.
+         * @param destinationKey Destination key, for instance the destination type name.
+         * @param sourceObject The source object to map.
+         * @returns {any} Destination object.
+         */
+        map(sourceKey: string | (new() => any), destinationKey: string | (new() => any), sourceObject: any): any;
+
+        /**
+         * Create a mapAsync curry function which expects a destination key, a source object and a callback function.
+         * @param sourceKey Source key, for instance the source type name.
+         * @returns {(destinationKey: string, sourceObject: any, callback: IMapCallback) => void}
+         */
+        mapAsync(sourceKey: string | (new() => any)): (destinationKey: string | (new() => any), sourceObject: any, callback: IMapCallback) => void;
+
+        /**
+         * Create a map curry function which expects only a source object and a callback function.
+         * @param sourceKey Source key, for instance the source type name.
+         * @param destinationKey Destination key, for instance the destination type name.
+         * @param sourceObject The source object to map.
+         * @returns {(callback: IMapCallback) => void}
+         */
+        mapAsync(sourceKey: string | (new() => any), destinationKey: string | (new() => any), sourceObject: any): (callback: IMapCallback) => void;
+
+        /**
+         * Create a map curry function which expects only a source object and a callback function.
+         * @param sourceKey Source key, for instance the source type name.
+         * @param destinationKey Destination key, for instance the destination type name.
+         * @returns {(sourceObject: any, callback: IMapCallback) => void}
+         */
+        mapAsync(sourceKey: string | (new() => any), destinationKey: string | (new() => any)): (sourceObject: any, callback: IMapCallback) => void;
+
+        /**
+         * Execute an asynchronous mapping from the source object to a new destination object with explicit mapping configuration and supplied mapping options (using createMap).
+         * @param sourceKey Source key, for instance the source type name.
+         * @param destinationKey Destination key, for instance the destination type name.
+         * @param sourceObject The source object to map.
+         * @param {IMapCallback} callback The callback to call when asynchronous mapping is complete.
+         */
+        mapAsync(sourceKey: string | (new() => any), destinationKey: string | (new() => any), sourceObject: any, callback: IMapCallback): void;
+
+        /**
+         * Validates mapping configuration by dry-running. Since JS does not
+         * fully support typing, it only checks if properties match on both
+         * sides. The function needs IMapping.sourceTypeClass and 
+         * IMapping.destinationTypeClass to function.
+         * @param {boolean} strictMode Whether or not to fail when properties
+         *                             sourceTypeClass or destinationTypeClass
+         *                             are unavailable. 
+         */
+        assertConfigurationIsValid(strictMode?: boolean): void;
+    }
+
+    class AsyncAutoMapper {
+        /* For Test Purposes Only */
+    }
+
+    /**
+     * Converts source type to destination type instead of normal member mapping
+     */
+    class TypeConverter implements ITypeConverter {
+        /**
+         * Performs conversion from source to destination type.
+         * @param {IResolutionContext} resolutionContext Resolution context.
+         * @returns {any} Destination object.
+         */
+        convert(resolutionContext: IResolutionContext): any;
+    }
+
+    export class Profile implements IProfile {
+        /** Profile name */
+        public profileName: string;
+        
+        /** Naming convention for source members */
+        public sourceMemberNamingConvention: INamingConvention;
+        
+        /** Naming convention for destination members */
+        public destinationMemberNamingConvention: INamingConvention;
+        
+        /**
+         * Create a createMap curry function which expects only a destination key.
+         * @param {string} sourceKey The map source key.
+         * @returns {(destinationKey: string) => ICreateMapFluentFunctions}
+         */
+        protected createMap(sourceKey: string): (destinationKey: string) => ICreateMapFluentFunctions;
+
+        /**
+         * Create a mapping profile.
+         * @param {string} sourceKey The map source key.
+         * @param {string} destinationKey The map destination key.
+         * @returns {Core.ICreateMapFluentFunctions}
+         */
+        protected createMap(sourceKey: string, destinationKey: string): ICreateMapFluentFunctions;
+        
+        /**
+         * Implement this method in a derived class and call the CreateMap method to associate that map with this profile.
+         * Avoid calling the AutoMapper class / automapper instance from this method. 
+         */
+        public configure(): void;
+    }
+    
+    /**
+     * Defines the PascalCase naming convention strategy.
+     */
+    class PascalCaseNamingConvention implements INamingConvention {
+        /** Regular expression on how to tokenize a member. */
+        splittingExpression: RegExp;
+
+        /** Character to separate on. */
+        separatorCharacter: string;
+
+        /**
+         * Transformation function called when this convention is the destination naming convention.
+         * @param {string[]} sourcePropertyNameParts Array containing tokenized source property name parts.
+         * @returns {string} Destination property name
+         */
+        transformPropertyName(sourcePropertyNameParts: string[]): string;
+    }
+    
+    /**
+     * Defines the camelCase naming convention strategy.
+     */
+    class CamelCaseNamingConvention implements INamingConvention {
+        /** Regular expression on how to tokenize a member. */
+        splittingExpression: RegExp;
+
+        /** Character to separate on. */
+        separatorCharacter: string;
+
+        /**
+         * Transformation function called when this convention is the destination naming convention.
+         * @param {string[]} sourcePropertyNameParts Array containing tokenized source property name parts.
+         * @returns {string} Destination property name
+         */
+        transformPropertyName(sourcePropertyNameParts: string[]): string;
+    }
+
+
+
+    interface IProperty {
+        name: string;
+        metadata: IPropertyMetadata;
+        level: number;
+        sourceMapping: boolean;
+        ignore: boolean;
+        async: boolean;
+        children?: IProperty[];
+        destinations?: IProperty[];
+        conversionValuesAndFunctions: any[];
+        conditionFunction?: (sourceObject: any) => boolean;
+    }
+
+    interface IPropertyMetadata {
+        mapping: IMapping;
+        root: IProperty;
+        parent: IProperty;
+        destinations: {[name: string]: IPropertyDestinationMetadata};
+        destinationCount: number;
+    }
+
+    interface IPropertyDestinationMetadata {
+        source: IProperty;
+        destination: IProperty;
+    }
+
+    interface IMemberMappingMetaData {
+        destination: string;
+        source: string;
+        sourceMapping: boolean;
+        ignore: boolean;
+        async: boolean;
+        condition: (sourceObject: any) => boolean;
+    }
+
+    /**
+     * Member mapping properties.
+     */
+    interface IForMemberMapping {
+        /** The source member property name. */
+        sourceProperty: string;
+        /** The destination member property name parts for nested property support (e.g. 'type.name'). */
+        destinationProperty: string;
+        /** Source or destination mapping. */
+        sourceMapping: boolean;
+        /** All mapping values and/or functions resulting from stacked for(Source)Member calls. */
+        mappingValuesAndFunctions: Array<any>;
+        /** Whether or not this destination property must be ignored. */
+        ignore: boolean;
+        /** Whether or not this member mapping has an asynchronous mapping function. */
+        async: boolean;
+        /** 
+         * The object will only be mapped when the condition is met.
+         * @param {any} sourceObject The source object to check.
+         * @returns {boolean}
+         */
+        conditionFunction: (sourceObject: any) => boolean;
+    }
+
+    /**
+     * Interface for returning an object with available 'sub' functions to enable method chaining (e.g. automapper.createMap().forMember().forMember() ...)
+     */
+    interface ICreateMapFluentFunctions {
+        /**
+         * Customize configuration for an individual destination member.
+         * @param sourceProperty The destination member property name.
+         * @param valueOrFunction The value or function to use for this individual member.
+         * @returns {IAutoMapperCreateMapChainingFunctions}
+         */
+        forMember: (sourceProperty: string, valueOrFunction: any |
+                     ((opts: IMemberConfigurationOptions) => any) |
+                     ((opts: IMemberConfigurationOptions, cb: IMemberCallback) => void)) => ICreateMapFluentFunctions;
+
+        /**
+         * Customize configuration for an individual source member.
+         * @param sourceProperty The source member property name.
+         * @param sourceMemberConfigFunction The function to use for this individual member.
+         * @returns {IAutoMapperCreateMapChainingFunctions}
+         */
+        forSourceMember: (sourceProperty: string,
+                          sourceMemberConfigFunction: ((opts: ISourceMemberConfigurationOptions) => any) |
+                                                      ((opts: ISourceMemberConfigurationOptions, cb: IMemberCallback) => void)
+                         ) => ICreateMapFluentFunctions;
+
+        /**
+         * Customize configuration for all destination members.
+         * @param func The function to use for this individual member.
+         * @returns {IAutoMapperCreateMapChainingFunctions}
+         */
+        forAllMembers: (func: (destinationObject: any, destinationPropertyName: string, value: any) => void) => ICreateMapFluentFunctions;
+
+        /**
+         * Ignore all members not specified explicitly.
+         */
+        ignoreAllNonExisting: () => ICreateMapFluentFunctions;
+
+        /**
+         * Skip normal member mapping and convert using a custom type converter (instantiated during mapping).
+         * @param typeConverterClassOrFunction The converter class or function to use when converting.
+         */
+        convertUsing: (typeConverterClassOrFunction: ((resolutionContext: IResolutionContext) => any) |
+                                                     ((resolutionContext: IResolutionContext, callback: IMapCallback) => void) |
+                                                     ITypeConverter |
+                                                     (new() => ITypeConverter)
+                      ) => void;
+
+        /**
+         * Specify to which class type AutoMapper should convert. When specified, AutoMapper will create an instance of the given type, instead of returning a new object literal.
+         * @param typeClass The destination type class.
+         * @returns {IAutoMapperCreateMapChainingFunctions}
+         */
+        convertToType: (typeClass: new () => any) => ICreateMapFluentFunctions;
+
+        /**
+         * Specify which profile should be used when mapping.
+         * @param {string} profileName The profile name.
+         * @returns {IAutoMapperCreateMapChainingFunctions}
+         */
+        withProfile: (profileName: string) => void;
+    }
+
+    /**
+     * The mapping configuration for the current mapping keys/types.
+     */
+    interface IMapping {
+        /** The mapping source key. */
+        sourceKey: string;
+
+        /** The mapping destination key. */
+        destinationKey: string;
+
+        /** The mappings for forAllMembers functions. */
+        forAllMemberMappings: Array<(destinationObject: any, destinationPropertyName: string, value: any) => void>;
+
+        properties: IProperty[];
+
+        /**
+         * Skip normal member mapping and convert using a type converter.
+         * @param resolutionContext Context information regarding resolution of a destination value
+         * @returns {any} Destination object.
+         */
+        typeConverterFunction: ((resolutionContext: IResolutionContext) => any) |
+                               ((resolutionContext: IResolutionContext, callback: IMapCallback) => void);
+
+        /** The source type class to convert from. */
+        sourceTypeClass: any;
+
+        /** The destination type class to convert to. */
+        destinationTypeClass: any;
+
+        /** The profile used when mapping. */
+        profile?: IProfile;
+
+        /** Whether or not to ignore all properties not specified using createMap. */
+        ignoreAllNonExisting?: boolean;
+
+        /** Whether or not an mapping has to be asynchronous. */
+        async: boolean;
+
+        /*
+         * PERFORMANCE ENHANCEMENTS
+         */
+
+        /**
+         * Item mapping function to use.
+         */
+        mapItemFunction: IMapItemFunction | IAsyncMapItemFunction;
+    }
+
+    // export interface IMappingMapOptimized extends IMapping {
+    //     final: boolean;
+    //     forMemberMappingsArray: Array<IForMemberMapping>;
+    // }
+
+    /**
+     * Context information regarding resolution of a destination value
+     */
+    export interface IResolutionContext {
+        /** Source value */
+        sourceValue: any;
+
+        /** Destination value */
+        destinationValue: any;
+
+        /** Source property name */
+        sourcePropertyName?: string;
+
+        /** Destination property name */
+        destinationPropertyName?: string;
+
+        /** Index of current collection mapping */
+        arrayIndex?: number;
+    }
+
+    /**
+     * Configuration options for forMember mapping function.
+     */
+    interface IMemberConfigurationOptions {
+        /**
+         * Map from a custom source property name.
+         * @param sourcePropertyName The source property to map.
+         */
+        mapFrom: (sourcePropertyName: string) => void;
+
+        /** 
+         * When this configuration function is used, the (destination) property is ignored
+         * when mapping. 
+         */
+        ignore?: () => void;
+
+        /**
+         * If specified, the property will only be mapped when the condition is fulfilled.
+         */
+        condition: (predicate: ((sourceObject: any) => boolean)) => void;
+
+        /** The source object to map. */
+        sourceObject: any;
+
+        /** The source property to map. */
+        sourcePropertyName: string;
+
+        /**
+         * The intermediate destination property value, used for stacking multiple for(Source)Member calls 
+         * while elaborating the intermediate result.
+         */
+        intermediatePropertyValue: any;
+    }
+
+    /**
+     * Configuration options for forSourceMember mapping function.
+     */
+    interface ISourceMemberConfigurationOptions {
+        /**
+         * When this configuration function is used, the source property is ignored
+         * when mapping.
+         */
+        ignore: () => void;
+    }
+
+    /**
+     * Member callback interface
+     */
+    interface IMemberCallback {
+        /**
+         * Callback function to call when the async operation is executed.
+         * @param {any} callbackValue Callback value to be used as output for the for(Source)Member call.
+         */
+        (callbackValue: any): void;
+    }
+
+    /**
+     * Member callback interface
+     */
+    interface IMapCallback {
+        /**
+         * Callback function to call when the async operation is executed.
+         * @param {any} result Callback value to be used as output for the mapAsync call.
+         */
+        (result: any): void;
+    }
+
+    /**
+     * Converts source type to destination type instead of normal member mapping
+     */
+    export interface ITypeConverter {
+        /**
+         * Performs conversion from source to destination type.
+         * @param {IResolutionContext} resolutionContext Resolution context.
+         * @returns {any} Destination object.
+         */
+        convert: (resolutionContext: IResolutionContext) => any;
+    }
+
+    /**
+     * Defines a naming convention strategy.
+     */
+    export interface INamingConvention {
+        /** Regular expression on how to tokenize a member. */
+        splittingExpression: RegExp;
+
+        /** Character to separate on. */
+        separatorCharacter: string;
+
+        /**
+         * Transformation function called when this convention is the destination naming convention.
+         * @param {string[]} sourcePropertyNameParts Array containing tokenized source property name parts.
+         * @returns {string} Destination property name
+         */
+        transformPropertyName: (sourcePropertyNameParts: string[]) => string;
+    }
+
+    /**
+     * Configuration for profile-specific maps.
+     */
+    export interface IConfiguration {
+        /**
+         * Add an existing profile
+         * @param profile {IProfile} Profile to add.
+         */
+        addProfile(profile: IProfile): void;
+
+        /**
+         * Create a createMap curry function which expects only a destination key.
+         * @param {string} sourceKey The map source key.
+         * @returns {(destinationKey: string) => IAutoMapperCreateMapChainingFunctions}
+         */
+        createMap?(sourceKey: string): (destinationKey: string) => ICreateMapFluentFunctions;
+
+        /**
+         * Create a mapping profile.
+         * @param {string} sourceKey The map source key.
+         * @param {string} destinationKey The map destination key.
+         * @returns {Core.IAutoMapperCreateMapChainingFunctions}
+         */
+        createMap?(sourceKey: string, destinationKey: string): ICreateMapFluentFunctions;
+    }
+
+    /**
+     * Provides a named configuration for maps. Naming conventions become scoped per profile.
+     */
+    export interface IProfile {
+        /** Profile name */
+        profileName: string;
+
+        /** Naming convention for source members */
+        sourceMemberNamingConvention: INamingConvention;
+
+        /** Naming convention for destination members */
+        destinationMemberNamingConvention: INamingConvention;
+
+        /**
+         * Implement this method in a derived class and call the CreateMap method to associate that map with this profile.
+         * Avoid calling the AutoMapper class / automapper instance from this method. 
+         */
+        configure: () => void;
+    }
+
+    export interface IMapItemFunction {
+        (mapping: IMapping, sourceObject: any, destinationObject: any): any;
+    }
+
+    export interface IAsyncMapItemFunction {
+        (mapping: IMapping, sourceObject: any, destinationObject: any, callback: IMapCallback): void;
+    }
+
+    interface ICreateMapParameters {
+        mapping: IMapping;
+        destinationProperty: string;
+        conversionValueOrFunction: any;
+        sourceMapping: boolean;
+        fluentFunctions: ICreateMapFluentFunctions;
+    }
+
+    interface IGetOrCreatePropertyParameters {
+        propertyNameParts: string[];
+        mapping: IMapping;
+        parent?: IProperty;
+        propertyArray: IProperty[];
+        destination?: string;
+        sourceMapping: boolean;
+    }
+
+    interface ICreatePropertyParameters {
+        name: string;
+        mapping: IMapping;
+        parent: IProperty;
+        propertyArray: IProperty[];
+        sourceMapping: boolean;
+    }
+}
+
+declare var automapper: AutoMapperJs.AutoMapper;

aws-sdk/index.d.ts

@@ -378,7 +378,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;
@@ -2253,6 +2254,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;

billplz/billplz-tests.ts

@@ -0,0 +1,46 @@
+/// <reference path="billplz.d.ts" />
+
+import * as Billplz from 'billplz';
+
+const billplz = new Billplz({
+  key: 'your-api-key',
+  endpoint: 'http://localhost/',
+  sandbox: true
+});
+
+// test create collection
+billplz.create_collection({
+  title: 'your-title'
+});
+
+// test create open collection
+billplz.create_collectionOpen({
+  title: 'your-title',
+  description: 'your-description',
+  amount: 100
+});
+
+// test create bill
+billplz.create_bill({
+  collection_id: 'your-collection-id',
+  description: 'your-description',
+  email: 'your-email',
+  mobile: 12345,
+  name: 'your-name',
+  amount: 100,
+  callback_url: 'https://example.com/webhook/',
+  redirect_url: 'https://example.com/done',
+  due_at: '0000-00-00'
+});
+
+// test get bill
+billplz.get_bill('your-bill-id');
+
+// test delete bill
+billplz.delete_bill('your-bill-id');
+
+// test change collection status
+billplz.change_collection_status('your-collection-id', 'status-here');
+
+// test registration check
+billplz.registration_check('your-bank-account-number');

billplz/billplz.d.ts

@@ -0,0 +1,80 @@
+// Type definitions for billplz 1.0.2
+// Project: https://github.com/suhz/node-billplz
+// Definitions by: Akim <https://github.com/Akim95>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module Billplz {
+    // api options type
+    interface BillplzOptions {
+        key: string;
+        endpoint?: string;
+        sandbox?: boolean;
+    }
+
+    // collection type
+    interface CollectionArguments {
+        title: string;
+    }
+
+    // open collection type
+    interface OpenCollectionArguments {
+        title: string;
+        description: string;
+        amount: number;
+        fixed_amount?: boolean;
+        fixed_quantity?: boolean;
+        payment_button?: string;
+        reference_1_label?: string
+        reference_2_label?: string;
+        email_link?: string;
+        tax?: number;
+    }
+
+    // bill type
+    interface BillArguments {
+        collection_id: string;
+        email: string;
+        mobile: number;
+        name: string;
+        amount: number;
+        callback_url: string;
+        description: string;
+        due_at?: string;
+        redirect_url?: string;
+        deliver?: boolean;
+        reference_1_label?: string;
+        reference_1?: string;
+        reference_2_label?: string;
+        reference_2?: string;
+    }
+}
+
+declare class Billplz {
+    // constructor
+    constructor(options: string | Billplz.BillplzOptions);
+
+    // create_collection
+    create_collection(title: Billplz.CollectionArguments, callback?: (res: any, err: any) => void): void;
+
+    // create collectionOpen
+    create_collectionOpen(args: Billplz.OpenCollectionArguments, callback?: (res: any, err: any) => void): void;
+
+    // create bill
+    create_bill(args: Billplz.BillArguments, callback?: (res: any, err: any) => void): void;
+
+    // get bill
+    get_bill(billId: string, callback?: (res: any, err: any) => void): void;
+
+    // delete bill
+    delete_bill(billId: string, callback?: (res: any, err: any) => void): void;
+
+    // change_collection status
+    change_collection_status(collectionId: string, status: string, callback?: (res: any, err: any) => void): void;
+
+    // registration check
+    registration_check(bankAccountNumber: string, callback?: (res: any, err: any) => void): void;
+}
+
+declare module "billplz" {
+    export = Billplz;
+}

bootstrap-select/bootstrap-select-tests.ts

@@ -0,0 +1,43 @@
+// Bootstrap Select Test
+// ================================================================================
+/// <reference path="bootstrap-select.d.ts" />
+/// <reference path="../jquery/jquery.d.ts"/>
+
+$(".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/bootstrap-select.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 path="../jquery/jquery.d.ts"/>
+
+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
+}

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;
     }
 

color/color-tests.ts

@@ -0,0 +1,85 @@
+// Color Test
+// ================================================================================
+/// <reference path="color.d.ts"/>
+
+// Imports
+// --------------------------------------------------------------------------------
+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/color.d.ts

@@ -0,0 +1,162 @@
+// 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 module "color" {
+    const Color: Color.Color
+    export = Color
+}

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

@@ -0,0 +1,121 @@
+/// <reference path='./cordova-plugin-ble-central.d.ts' />
+
+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/cordova-plugin-ble-central.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.plugins.diagnostic/cordova.plugins.diagnostic-tests.ts

@@ -0,0 +1,534 @@
+/// <reference path='../cordova/cordova.d.ts'  />
+/// <reference path="cordova.plugins.diagnostic.d.ts" />
+
+
+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/cordova.plugins.diagnostic.d.ts

@@ -0,0 +1,737 @@
+// 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
+
+
+/**
+ * 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
+}

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

@@ -0,0 +1,11 @@
+// Credit Card Type Test
+// ================================================================================
+///<reference path="credit-card-type.d.ts"/>
+
+// Imports
+// --------------------------------------------------------------------------------
+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/credit-card-type.d.ts

@@ -0,0 +1,32 @@
+// 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 module "credit-card-type" {
+    const creditCardType: CreditCardType.CreditCardType
+    export = creditCardType
+}

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,15 @@
+// ES6 Error Test
+// ================================================================================
+/// <reference path="es6-error.d.ts"/>
+
+// Imports
+// --------------------------------------------------------------------------------
+import * as ExtendableError from "es6-error"
+
+class TestError extends ExtendableError {
+    constructor (message: string = "TestError") {
+        super(message)
+    }
+}
+
+throw new TestError("Test Message")

es6-error/es6-error.d.ts

@@ -0,0 +1,8 @@
+// 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
+
+declare module "es6-error" {
+    export = Error
+}

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,51 @@
+/// <reference path="fusioncharts.d.ts" />
+
+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/fusioncharts.d.ts

@@ -0,0 +1,302 @@
+// 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 module 'FusionCharts' {
+    var FusionCharts: FusionCharts.FusionChartStatic;
+    export = FusionCharts;
+}
+
+declare var FusionCharts: FusionCharts.FusionChartStatic;
+
+

gapi.analytics/gapi.analytics-tests.ts

@@ -0,0 +1,66 @@
+// Type definitions for Google Analytics API
+
+/// <reference path="../gapi/gapi.d.ts" />
+/// <reference path="./gapi.analytics.d.ts" />
+
+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/gapi.analytics.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 path="../gapi/gapi.d.ts" />
+
+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>;
+}

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() {

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 {
@@ -287,6 +291,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> {
@@ -827,10 +841,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).
  */
@@ -878,3 +900,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};
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
@@ -221,6 +222,8 @@ namespace common {
 	anySchema = anySchema.empty();
 	anySchema = anySchema.empty(str);
 	anySchema = anySchema.empty(anySchema);
+	
+	anySchema = anySchema.error(err);
 }
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
@@ -756,30 +759,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, {});
 
 // --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
 
@@ -801,3 +831,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);

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/jquery.rateit-tests.ts

@@ -0,0 +1,48 @@
+/// <reference path="jquery.rateit.d.ts"/>
+
+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/jquery.rateit.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 path="../jquery/jquery.d.ts"/>
+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;
+}

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 {
@@ -1185,6 +1221,15 @@ declare namespace L {
         distance: number;
     }
 
+    export namespace DomEvent {
+        export function on(el: HTMLElement, types: string, fn: Function, context?: Object): typeof DomEvent;
+        export function on(el: HTMLElement, eventMap: {[eventName: string]: Function}, context?: Object): typeof DomEvent;
+        export function off(el: HTMLElement, types: string, fn: Function, context?: Object): typeof DomEvent;
+        export function off(el: HTMLElement, eventMap: {[eventName: string]: Function}, context?: Object): typeof DomEvent;
+        export function disableScrollPropagation(el: HTMLElement): typeof DomEvent;
+        export function disableClickPropagation(el: HTMLElement): typeof DomEvent;
+    }
+
     interface DefaultMapPanes {
         mapPane: HTMLElement;
         tilePane: HTMLElement;

leaflet/leaflet-tests.ts

@@ -207,6 +207,14 @@ tileLayer = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png');
 tileLayer = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', tileLayerOptions);
 tileLayer = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png?{foo}&{bar}&{abc}', {foo: 'bar', bar: (data: any) => 'foo', abc: () => ''});
 
+let eventHandler = () => {};
+L.DomEvent.on(htmlElement, 'click', eventHandler);
+L.DomEvent.off(htmlElement, 'click', eventHandler);
+L.DomEvent.on(htmlElement, { 'click': eventHandler });
+L.DomEvent.off(htmlElement, { 'click': eventHandler }, eventHandler);
+L.DomEvent.disableScrollPropagation(htmlElement);
+L.DomEvent.disableClickPropagation(htmlElement);
+
 map = map
 	// addControl
 	// removeControl

lowlight/lowlight-tests.ts

@@ -0,0 +1,82 @@
+/// <reference path="lowlight.d.ts" />
+
+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/lowlight.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;
+    }
+}

mapbox-gl/index.d.ts

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

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

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

mocha/index.d.ts

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

nes/nes.d.ts

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

noble/index.d.ts

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

node/index.d.ts

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

node/node-4-tests.ts

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

node/node-4.d.ts

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

node/node-tests.ts

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

paper/paper-tests.ts

@@ -0,0 +1,38 @@
+/// <reference path="paper.d.ts" />
+
+import paper = require('paper');
+
+var canvas = document.createElement('canvas')
+
+paper.setup(canvas);
+
+// Circle
+var path = paper.Path.Circle({
+	center: [80, 50],
+	radius: 35,
+	fillColor: 'red'
+});
+
+// Dotted Line Tool
+var dottedLinePath: paper.Path;
+var dottedLineTool = new paper.Tool();
+
+dottedLineTool.onMouseDown = function(event: any) {
+    new paper.Layer().activate();
+    dottedLinePath = new paper.Path();
+    dottedLinePath.strokeColor = '#00';
+    dottedLinePath.strokeWidth = 2;
+    dottedLinePath.dashArray = [5, 8];
+    dottedLinePath.strokeCap = 'round';
+    dottedLinePath.strokeJoin = 'round';
+    dottedLinePath.add(event.point);
+};
+
+dottedLineTool.onMouseDrag = function(event: any) {
+    dottedLinePath.add(event.point);
+};
+
+dottedLineTool.onMouseUp = function(event: any) {
+    dottedLinePath.smooth();
+    dottedLinePath.simplify();
+};

pegjs/index.d.ts

@@ -1,6 +1,6 @@
-// Type definitions for PEG.js
+// Type definitions for PEG.js v0.10.0
 // Project: http://pegjs.org/
-// Definitions by: vvakame <https://github.com/vvakame>, Tobias Kahlert <https://github.com/SrTobi>
+// Definitions by: vvakame <https://github.com/vvakame>, Tobias Kahlert <https://github.com/SrTobi>, C.J. Bell <https://github.com/siegebell>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare namespace PEG {
@@ -61,19 +61,70 @@ export interface Parser {
     SyntaxError: any;
 }
 
-export interface BuildOptions {
-    cache?: boolean;
+export interface BuildOptionsBase {
+    /** rules the parser will be allowed to start parsing from (default: the first rule in the grammar) */
     allowedStartRules?: string[];
-    optimize?: string;
+    /** if `true`, makes the parser cache results, avoiding exponential parsing time in pathological cases but making the parser slower (default: `false`) */
+    cache?: boolean;
+    /** selects between optimizing the generated parser for parsing speed (`"speed"`) or code size (`"size"`) (default: `"speed"`) */
+    optimize?: "speed" | "size";
+    /** plugins to use */
     plugins?: any[];
+    /** makes the parser trace its progress (default: `false`) */
+    trace?: boolean
 }
 
-export interface OutputBuildOptions extends BuildOptions {
-    output?: string;
+export interface ParserBuildOptions extends BuildOptionsBase {
+    /** if set to `"parser"`, the method will return generated parser object; if set to `"source"`, it will return parser source code as a string (default: `"parser"`) */
+    output?: "parser"
 }
 
-export function buildParser(grammar: string, options?: BuildOptions): Parser;
-export function buildParser(grammar: string, options?: OutputBuildOptions): Parser | string;
+export interface OutputFormatAmdCommonjs extends BuildOptionsBase {
+    /** if set to `"parser"`, the method will return generated parser object; if set to `"source"`, it will return parser source code as a string (default: `"parser"`) */
+    output: "source";
+    /** format of the genreated parser (`"amd"`, `"bare"`, `"commonjs"`, `"globals"`, or `"umd"`); valid only when `output` is set to `"source"` (default: `"bare"`) */
+    format: "amd" | "commonjs";
+    /** parser dependencies, the value is an object which maps variables used to access the dependencies in the parser to module IDs used to load them; valid only when `format` is set to `"amd"`, `"commonjs"`, or `"umd"` (default: `{}`) */
+    dependencies?: any
+}
+
+export interface OutputFormatUmd extends BuildOptionsBase {
+    /** if set to `"parser"`, the method will return generated parser object; if set to `"source"`, it will return parser source code as a string (default: `"parser"`) */
+    output: "source";
+    /** format of the genreated parser (`"amd"`, `"bare"`, `"commonjs"`, `"globals"`, or `"umd"`); valid only when `output` is set to `"source"` (default: `"bare"`) */
+    format: "umd";
+    /** parser dependencies, the value is an object which maps variables used to access the dependencies in the parser to module IDs used to load them; valid only when `format` is set to `"amd"`, `"commonjs"`, or `"umd"` (default: `{}`) */
+    dependencies?: any
+    /** name of a global variable into which the parser object is assigned to when no module loader is detected; valid only when `format` is set to `"globals"` or `"umd"` (default: `null`) */
+    exportVar?: any
+}
+
+export interface OutputFormatGlobals extends BuildOptionsBase {
+    /** if set to `"parser"`, the method will return generated parser object; if set to `"source"`, it will return parser source code as a string (default: `"parser"`) */
+    output: "source";
+    /** format of the genreated parser (`"amd"`, `"bare"`, `"commonjs"`, `"globals"`, or `"umd"`); valid only when `output` is set to `"source"` (default: `"bare"`) */
+    format: "globals";
+    /** name of a global variable into which the parser object is assigned to when no module loader is detected; valid only when `format` is set to `"globals"` or `"umd"` (default: `null`) */
+    exportVar?: any
+}
+
+export interface OutputFormatBare extends BuildOptionsBase {
+    /** if set to `"parser"`, the method will return generated parser object; if set to `"source"`, it will return parser source code as a string (default: `"parser"`) */
+    output: "source";
+    /** format of the genreated parser (`"amd"`, `"bare"`, `"commonjs"`, `"globals"`, or `"umd"`); valid only when `output` is set to `"source"` (default: `"bare"`) */
+    format?: "bare"
+}
+
+/** Returns a generated parser object. It will throw an exception if the grammar is invalid. The exception will contain `message` property with more details about the error. */
+export function generate(grammar: string, options?: ParserBuildOptions): Parser;
+/** Returns the generated source code as a `string`. It will throw an exception if the grammar is invalid. The exception will contain `message` property with more details about the error. */
+export function generate(grammar: string, options: OutputFormatAmdCommonjs): string;
+/** Returns the generated source code as a `string`. It will throw an exception if the grammar is invalid. The exception will contain `message` property with more details about the error. */
+export function generate(grammar: string, options: OutputFormatUmd): string;
+/** Returns the generated source code as a `string`. It will throw an exception if the grammar is invalid. The exception will contain `message` property with more details about the error. */
+export function generate(grammar: string, options: OutputFormatGlobals): string;
+/** Returns the generated source code as a `string`. It will throw an exception if the grammar is invalid. The exception will contain `message` property with more details about the error. */
+export function generate(grammar: string, options: OutputFormatBare): string;
 
 export namespace parser {
     type SyntaxError = PegjsError;

pegjs/pegjs-tests.ts

@@ -6,7 +6,7 @@ import * as pegjs from 'pegjs';
 }
 
 {
-    let pegparser: pegjs.Parser = pegjs.buildParser("start = ('a' / 'b')+");
+    let pegparser: pegjs.Parser = pegjs.generate("start = ('a' / 'b')+");
 
     try {
         let result: string = pegparser.parse("abba");
@@ -18,7 +18,7 @@ import * as pegjs from 'pegjs';
 }
 
 {
-    let parser = pegjs.buildParser("A = 'test'", {
+    let parser = pegjs.generate("A = 'test'", {
         cache: true,
         allowedStartRules: ["A"],
         optimize: "speed",
@@ -27,7 +27,7 @@ import * as pegjs from 'pegjs';
 }
 
 try {
-    let parserOrSource: pegjs.Parser | string = pegjs.buildParser("A = 'test'", {output: "source"});
+    let source: string = pegjs.generate("A = 'test'", {output: "source"});
 } catch (error) {
     if (error instanceof pegjs.GrammarError) {
         let e: pegjs.GrammarError = error;

pixi.js/index.d.ts

@@ -1106,7 +1106,7 @@ declare namespace PIXI {
 
         static uuid(): number;
         static hex2rgb(hex: number, out?: number[]): number[];
-        static hex2String(hex: number): string;
+        static hex2string(hex: number): string;
         static rgb2hex(rgb: Number[]): number;
         static canUseNewCanvasBlendModel(): boolean;
         static getNextPowerOfTwo(number: number): number;

pixi.js/pixi.js-tests.ts

@@ -461,7 +461,7 @@ namespace basics {
 
             var style: PIXI.TextStyle = {
                 font: '36px Arial bold italic',
-                fill: '#F7EDCA',
+                fill: PIXI.utils.hex2string(0xF7EDCA),
                 stroke: '#4a1850',
                 strokeThickness: 5,
                 dropShadow: true,

polymer/index.d.ts

@@ -7,7 +7,7 @@
 
 declare namespace polymer {
 
-  type PropConstructorType = StringConstructor|ObjectConstructor|BooleanConstructor|NumberConstructor|DateConstructor|ArrayConstructor;
+  type PropConstructorType = StringConstructor | ObjectConstructor | BooleanConstructor | NumberConstructor | DateConstructor | ArrayConstructor;
 
   interface PropObjectType {
     type: PropConstructorType;
@@ -292,25 +292,42 @@ declare namespace polymer {
   }
 
   interface Settings {
+      hasNativeCSSProperties: boolean
+      hasNativeImports: boolean
+      hasShadow: boolean
+      nativeShadow: boolean
+      useNativeCSSProperties: boolean
+      useNativeCustomElements: boolean
+      useNativeImports: boolean
+      useNativeShadow: boolean
+      usePolyfillProto: boolean
+      useShadow: boolean
+      wantShadow: boolean
+  }
 
-    wantShadow:boolean;
-    hasShadow:boolean;
-    nativeShadow:boolean;
-    useShadow:boolean;
-    useNativeShadow:boolean;
-    useNativeImports:boolean;
-    useNativeCustomElements:boolean;
+  interface RenderStatus {
+    afterNextRender(element: Element, fn: Function, args?: any): void;
+    hasRendered(): boolean;
+    whenReady(cb: Function): void;
+  }
+
+  interface ImportStatus extends RenderStatus {
+    whenLoaded(cb: Function): void;
   }
 
   interface PolymerStatic {
-
     Settings: Settings;
 
-    dom:DomApiStatic;
+    dom: DomApiStatic;
 
-    (prototype: Base|{new ():Base}):webcomponents.CustomElementConstructor;
+    (prototype: Base | { new (): Base }): webcomponents.CustomElementConstructor;
 
-    Class(prototype: Base|{new ():Base}):webcomponents.CustomElementConstructor;
+    Class(prototype: Base | { new (): Base }): webcomponents.CustomElementConstructor;
+
+    RenderStatus: RenderStatus
+
+    /** @deprecated */
+    ImportStatus: ImportStatus
   }
 }
 

prompt-sync-history/prompt-sync-history-tests.ts

@@ -0,0 +1,12 @@
+/// <reference path="./prompt-sync-history" />
+/// <reference path="../prompt-sync/prompt-sync" />
+'use strict';
+
+import * as promptHistory from 'prompt-sync-history';
+import * as PromptSync from 'prompt-sync';
+
+let history:PromptSync.History;
+
+history = promptHistory();
+history = promptHistory('/path/to/file');
+history = promptHistory(null, 1000);

prompt-sync-history/prompt-sync-history.d.ts

@@ -0,0 +1,15 @@
+// Type definitions for prompt-sync-history 1.0.1
+// Project: https://github.com/davidmarkclements/prompt-sync-history
+// Definitions by: TANAKA Koichi <https://github.com/MugeSo>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../prompt-sync/prompt-sync" />
+
+declare module 'prompt-sync-history' {
+    import {History} from 'prompt-sync';
+
+    namespace history {}
+    function history(file?:string, max?:number): History;
+
+    export = history;
+}

prompt-sync/prompt-sync-tests.ts

@@ -0,0 +1,55 @@
+/// <reference path="./prompt-sync" />
+'use strict';
+
+import * as promptSync from 'prompt-sync';
+
+declare const history: promptSync.History;
+
+let prompt: promptSync.Prompt;
+
+// without config
+prompt = promptSync();
+
+// with config
+prompt = promptSync({
+    history: history,
+    sigint: false,
+    autocomplete: (input:string) => [input]
+});
+
+// with empty config
+prompt = promptSync({});
+
+let name:string = prompt('Enter name: ');
+let nickname:string = prompt({ask: 'Enter nickname: ', value: 'N/A'});
+let gender:string = prompt('Enter gender: ', { autocomplete: complete(['male', 'female']) });
+let age:string = prompt('Enter age: ', '18', { echo: '*' });
+let password:string = prompt.hide('Enter password: ');
+let anotherPassword:string = prompt('Enter another password: ', { echo: '', value: '*password*'});
+
+function complete(commands: string[]) {
+    return function (str: string) {
+        const ret:string[] = [];
+        for (let i=0; i< commands.length; i++) {
+            if (commands[i].indexOf(str) == 0)
+                ret.push(commands[i]);
+        }
+        return ret;
+    };
+}
+
+// History interface
+let bool: boolean;
+
+bool = history.atStart();
+bool = history.atPenultimate();
+bool = history.pastEnd();
+bool = history.atEnd();
+
+let str: string;
+str = history.prev();
+str = history.next();
+
+history.reset();
+history.push('aaa');
+history.save();

prompt-sync/prompt-sync.d.ts

@@ -0,0 +1,75 @@
+// Type definitions for prompt-sync 4.1.4
+// Project: https://github.com/0x00A/prompt-sync
+// Definitions by: TANAKA Koichi <https://github.com/MugeSo>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module 'prompt-sync' {
+    namespace PromptSync {
+        export interface Prompt {
+
+            (opts: Option): string;
+            (ask: string): string;
+            (ask: string, opts: Option): string;
+            (ask: string, value: string): string;
+            /**
+             * prompt -- sync function for reading user input from stdin
+             *  @param {String} ask opening question/statement to prompt for
+             *  @param {String} value initial value for the prompt
+             *  @param   {Object} opts {
+             *   echo: set to a character to be echoed, default is '*'. Use '' for no echo
+             *   value: {String} initial value for the prompt
+             *   ask: {String} opening question/statement to prompt for, does not override ask param
+             *   autocomplete: {StringArray} function({String})
+             * }
+             *
+             * @returns {string} Returns the string input or (if sigint === false)
+             *                   null if user terminates with a ^C
+             */
+            (ask: string, value: string, opts: Option): string;
+
+            hide(ask: string): string;
+        }
+
+        export interface Option {
+            ask?: string;
+            echo?: string;
+            autocomplete?: AutoCompleteFunction;
+            value?: string;
+        }
+
+        export interface Config {
+            sigint?: boolean;
+            autocomplete?: AutoCompleteFunction;
+            history?: History;
+        }
+
+        export interface History {
+            atStart(): boolean;
+            atPenultimate(): boolean;
+            pastEnd(): boolean;
+            atEnd(): boolean;
+            prev(): string;
+            next(): string;
+            reset(): void;
+            push(str: string): void;
+            save(): void;
+        }
+
+        export interface AutoCompleteFunction {
+            (input: string): string[];
+        }
+    }
+
+    /**
+     * create -- sync function for reading user input from stdin
+     * @param   {Object} config {
+     *   sigint: {Boolean} exit on ^C
+     *   autocomplete: {StringArray} function({String})
+     *   history: {String} a history control object (see `prompt-sync-history`)
+     * }
+     * @returns {Function} prompt function
+     */
+    function PromptSync(config?: PromptSync.Config): PromptSync.Prompt;
+
+    export = PromptSync;
+}

quill/index.d.ts

@@ -1,13 +1,28 @@
-// Type definitions for Quill
 // Project: http://quilljs.com
 // Definitions by: Sumit <https://github.com/sumitkm>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare namespace QuillJS {
+declare namespace Quill {
+
+    type Key = { key: string, shortKey?: boolean };
+    type Sources = "api" | "user" | "silent";
+    type Formats = { [key: string]: any };
+
+    export interface KeyboardStatic {
+        addBinding(key: Key, callback: (range: RangeStatic, context: any) => void): void;
+        addBinding(key: Key, context: any, callback: (range: RangeStatic, context: any) => void) : void;
+    }
+
+    export interface ClipboardStatic {
+        addMatcher(selector: string, callback: (node: any, delta: DeltaStatic) => DeltaStatic) : void;
+        addMatcher(nodeType: number, callback: (node: any, delta: DeltaStatic) => DeltaStatic) : void;
+        dangerouslyPasteHTML(html: string, source?: Sources): void;
+        dangerouslyPasteHTML(index: number, html: string, source?: Sources): void;
+    }
 
     export interface QuillOptionsStatic {
         debug?: string,
-        modules?: { [key: string]: any },
+        modules?: Formats,
         placeholder?: string,
         readOnly?: boolean,
         theme?: string,
@@ -22,11 +37,26 @@ declare namespace QuillJS {
     }
 
     export interface DeltaStatic {
+        new (ops: Array<any>) : DeltaStatic;
+        new (ops: any) : DeltaStatic;
         ops?: Array<any>;
-        retain?: any,
-        delete?: any,
-        insert?: any,
-        attributes?: any
+        retain(length: number, attributes: any) : DeltaStatic;
+        delete(length: number) : DeltaStatic;
+        filter(predicate: any) : DeltaStatic;
+        forEach(predicate: any) : DeltaStatic;
+        insert(text: any, attributes: any): DeltaStatic;
+        map(predicate: any) : DeltaStatic;
+        partition(predicate: any) : DeltaStatic;
+        reduce(predicate: any, initial: number): DeltaStatic;
+        chop() : DeltaStatic;
+        length(): number;
+        slice(start: number, end: number): DeltaStatic;
+        compose(other: any): DeltaStatic;
+        concat(other: DeltaStatic): DeltaStatic;
+        diff(other: DeltaStatic, index: number) : DeltaStatic;
+        eachLine(predicate: any, newline: any) : DeltaStatic;
+        transform(other: any, priority: any) : DeltaStatic;
+        transformPosition(index: number, priority: any) : DeltaStatic;
     }
 
     export interface RangeStatic {
@@ -35,62 +65,70 @@ declare namespace QuillJS {
         length: number;
     }
 
-    type sourceType = "api" | "user" | "silent";
-    type formatsType = { [key: string]: any };
-
-    export interface QuillStatic {
-        new (container: string | Element, options?: QuillOptionsStatic): QuillStatic;
-        deleteText(start: number, end: number, source?: sourceType): void;
+    export interface Quill {
+        new (container: string | Element, options?: QuillOptionsStatic): Quill;
+        deleteText(index: number, length: number, source?: Sources): void;
         disable(): void;
         enable(enabled?: boolean): void;
-        getContents(start?: number, end?: number): DeltaStatic;
+        getContents(index?: number, length?: number): DeltaStatic;
         getLength(): number;
-        getText(start?: number, end?: number): string;
-        insertEmbed(index: number, type: string, url: string, source?: sourceType): void;
-        insertText(index: number, text: string, source?: sourceType): void;
-        insertText(index: number, text: string, format: string, value: string, source?: sourceType): void;
-        insertText(index: number, text: string, formats: formatsType, source?: sourceType): void;
-        pasteHTML(index: number, html: string, source?:sourceType): string;
-        pasteHTML(html:string, source?: sourceType): string;
-        setContents(delta: DeltaStatic, source?: sourceType): void;
-        setText(text: string, source?: sourceType): void;
+        getText(index?: number, length?: number): string;
+        insertEmbed(index: number, type: string, value: any, source?: Sources): void;
+        insertText(index: number, text: string, source?: Sources): DeltaStatic;
+        insertText(index: number, text: string, format: string, value: any, source?: Sources): DeltaStatic;
+        insertText(index: number, text: string, formats: Formats, source?: Sources): DeltaStatic;
+        /**
+        * @deprecated Use clipboard.dangerouslyPasteHTML(index: number, html: string, source: Sources)
+        */
+        pasteHTML(index: number, html: string, source?: Sources): string;
+        /**
+        * @deprecated Use dangerouslyPasteHTML(html: string, source: Sources): void;
+        */
+        pasteHTML(html: string, source?: Sources): string;
+        setContents(delta: DeltaStatic, source?: Sources): DeltaStatic;
+        setText(text: string, source?: Sources): DeltaStatic;
         update(source?: string): void;
-        updateContents(delta: DeltaStatic, source?: sourceType): void;
+        updateContents(delta: DeltaStatic, source?: Sources): DeltaStatic;
 
-        format(name: string, value: any, source?: sourceType): void;
-        formatLine(index: number, length: number, source?: sourceType): void;
-        formatLine(index: number, length: number, format: string, value: any, source?: sourceType): void;
-        formatLine(index: number, length: number, formats: formatsType, source?: sourceType): void;
-        formatText(index: number, length: number, source?: sourceType): void;
-        formatText(index: number, length: number, format: string, value: any, source?: sourceType): void;
-        formatText(index: number, length: number, formats: formatsType, source?: sourceType): void;
-        getFormat(range?: RangeStatic): formatsType;
-        getFormat(index: number, length?: number): formatsType;
-        removeFormat(index: Number, length: Number, source?: sourceType): void;
+        format(name: string, value: any, source?: Sources): DeltaStatic;
+        formatLine(index: number, length: number, source?: Sources): DeltaStatic;
+        formatLine(index: number, length: number, format: string, value: any, source?: Sources): DeltaStatic;
+        formatLine(index: number, length: number, formats: Formats, source?: Sources): DeltaStatic;
+        formatText(index: number, length: number, source?: Sources): DeltaStatic;
+        formatText(index: number, length: number, format: string, value: any, source?: Sources): DeltaStatic;
+        formatText(index: number, length: number, formats: Formats, source?: Sources): DeltaStatic;
+        getFormat(range?: RangeStatic): Formats;
+        getFormat(index: number, length?: number): Formats;
+        removeFormat(index: number, length: number, source?: Sources): void;
 
         blur(): void;
         focus(): void;
         getBounds(index: number, length?: number): BoundsStatic;
         getSelection(focus?: boolean): RangeStatic;
         hasFocus(): boolean;
-        setSelection(index: number, length: number, source?: sourceType): void;
-        setSelection(range: RangeStatic, source?: sourceType): void;
+        setSelection(index: number, length: number, source?: Sources): void;
+        setSelection(range: RangeStatic, source?: Sources): void;
 
         on(eventName: string, callback: (<T>(delta: T, oldContents: T, source: string) => void) |
-            ((name: string, ...args: any[]) => void)): QuillStatic;
-        once(eventName: string, callback: (delta: DeltaStatic, source: string) => void): QuillStatic;
-        off(eventName: string, callback: (delta: DeltaStatic, source: string) => void): QuillStatic;
+            ((name: string, ...args: any[]) => void)): Quill;
+        once(eventName: string, callback: (delta: DeltaStatic, source: string) => void): Quill;
+        off(eventName: string, callback: (delta: DeltaStatic, source: string) => void): Quill;
 
         debug(level: string): void;
         import(path: string): any;
         register(path: string, def: any, suppressWarning?: boolean): void;
-        register(defs: formatsType, suppressWarning?: boolean): void;
+        register(defs: Formats, suppressWarning?: boolean): void;
         addContainer(className: string, refNode?: any): any;
+        addContainer(domNode: any, refNode?: any): any;
         getModule(name: string): any
+
+        clipboard: ClipboardStatic;
     }
 }
 
-declare var Quill: QuillJS.QuillStatic;
+declare var Quill: Quill.Quill;
+
+declare var Delta: Quill.DeltaStatic;
 
 declare module "quill" {
     export = Quill;

quill/quill-tests.ts

@@ -23,9 +23,14 @@ function test_enable() {
     quillEditor.enable();
 }
 
+function test_enable_false() {
+    let quillEditor = new Quill('#Editor');
+    quillEditor.enable(false);
+}
+
 function test_getContents() {
     var quillEditor = new Quill('#editor');
-    var delta: QuillJS.DeltaStatic = quillEditor.getContents();
+    var delta: Quill.DeltaStatic = quillEditor.getContents();
 }
 
 function test_getLength() {
@@ -93,24 +98,24 @@ function test_insertEmbed() {
 
 function test_updateContents() {
     var quillEditor = new Quill('#editor');
-    quillEditor.updateContents({
+    quillEditor.updateContents(new Delta({
         ops: [
             { retain: 6 },        // Keep 'Hello '
             { delete: 5 },        // 'World' is deleted
             { insert: 'Quill' },  // Insert 'Quill'
             { retain: 1, attributes: { bold: true } }    // Apply bold to exclamation mark
         ]
-    });
+    }));
 }
 
 function test_setContents() {
     var quillEditor = new Quill('#editor');
 
-    quillEditor.setContents([
+    quillEditor.setContents(new Delta({ ops: [
         { insert: 'Hello ' },
         { insert: 'World!', attributes: { bold: true } },
         { insert: '\n' }
-    ]);
+    ]}));
 }
 
 function test_setText() {

react-bytesize-icons/react-bytesize-icons-tests.tsx

@@ -0,0 +1,10 @@
+/// <reference path="../react/react-dom.d.ts" />
+/// <reference path="./react-bytesize-icons.d.ts" />
+
+import * as React from 'react';
+import {render} from 'react-dom';
+import {Activity, External, Export} from 'react-bytesize-icons';
+
+render(<Activity/>, document.getElementById('test'));
+render(<External width={42} color="blue"/>, document.getElementById('test'));
+render(<Export width={42} height={21} strokeWidth="10%" strokeLinejoin="bevel" strokeLinecap="butt" color="blue"/>, document.getElementById('test'));

react-bytesize-icons/react-bytesize-icons.d.ts

@@ -0,0 +1,106 @@
+// Type definitions for react-bytesize-icons 0.6.4
+// Project: https://github.com/abdelhai/react-bytesize-icons
+// Definitions by: rhysd <https://rhysd.github.io>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../react/react.d.ts" />
+
+declare module "react-bytesize-icons" {
+    export type StrokeLinejoin = "round" | "bevel" | "miter" | "inherit";
+    export type StrokeLinecap = "round" | "butt" | "square" | "inherit";
+    interface BytesizeIconsProps extends __React.Props<any> {
+        width?: number;
+        height?: number;
+        strokeWidth?: string;
+        strokeLinejoin?: StrokeLinejoin;
+        strokeLinecap?: StrokeLinecap;
+        color?: string;
+    }
+    export class BytesizeIconComponent extends __React.Component<BytesizeIconsProps, {}> {}
+
+    export class Activity extends BytesizeIconComponent {}
+    export class Alert extends BytesizeIconComponent {}
+    export class Archive extends BytesizeIconComponent {}
+    export class ArrowBottom extends BytesizeIconComponent {}
+    export class ArrowLeft extends BytesizeIconComponent {}
+    export class ArrowRight extends BytesizeIconComponent {}
+    export class ArrowTop extends BytesizeIconComponent {}
+    export class Backwards extends BytesizeIconComponent {}
+    export class Ban extends BytesizeIconComponent {}
+    export class Bell extends BytesizeIconComponent {}
+    export class Bookmark extends BytesizeIconComponent {}
+    export class Camera extends BytesizeIconComponent {}
+    export class CaretBottom extends BytesizeIconComponent {}
+    export class CaretLeft extends BytesizeIconComponent {}
+    export class CaretRight extends BytesizeIconComponent {}
+    export class CaretTop extends BytesizeIconComponent {}
+    export class Cart extends BytesizeIconComponent {}
+    export class Checkmark extends BytesizeIconComponent {}
+    export class ChevronBottom extends BytesizeIconComponent {}
+    export class ChevronLeft extends BytesizeIconComponent {}
+    export class ChevronRight extends BytesizeIconComponent {}
+    export class ChevronTop extends BytesizeIconComponent {}
+    export class Clock extends BytesizeIconComponent {}
+    export class Close extends BytesizeIconComponent {}
+    export class Code extends BytesizeIconComponent {}
+    export class Compose extends BytesizeIconComponent {}
+    export class Creditcard extends BytesizeIconComponent {}
+    export class Download extends BytesizeIconComponent {}
+    export class Send extends BytesizeIconComponent {}
+    export class Edit extends BytesizeIconComponent {}
+    export class Eject extends BytesizeIconComponent {}
+    export class EllipsisHorizontal extends BytesizeIconComponent {}
+    export class EllipsisVertical extends BytesizeIconComponent {}
+    export class End extends BytesizeIconComponent {}
+    export class Export extends BytesizeIconComponent {}
+    export class External extends BytesizeIconComponent {}
+    export class Book extends BytesizeIconComponent {}
+    export class Calendar extends BytesizeIconComponent {}
+    export class Print extends BytesizeIconComponent {}
+    export class Eye extends BytesizeIconComponent {}
+    export class File extends BytesizeIconComponent {}
+    export class Fire extends BytesizeIconComponent {}
+    export class Flag extends BytesizeIconComponent {}
+    export class FolderOpen extends BytesizeIconComponent {}
+    export class Folder extends BytesizeIconComponent {}
+    export class Forwards extends BytesizeIconComponent {}
+    export class Gift extends BytesizeIconComponent {}
+    export class Github extends BytesizeIconComponent {}
+    export class Heart extends BytesizeIconComponent {}
+    export class Home extends BytesizeIconComponent {}
+    export class Import extends BytesizeIconComponent {}
+    export class Inbox extends BytesizeIconComponent {}
+    export class Info extends BytesizeIconComponent {}
+    export class Lightning extends BytesizeIconComponent {}
+    export class Link extends BytesizeIconComponent {}
+    export class Location extends BytesizeIconComponent {}
+    export class Lock extends BytesizeIconComponent {}
+    export class Mail extends BytesizeIconComponent {}
+    export class Menu extends BytesizeIconComponent {}
+    export class Message extends BytesizeIconComponent {}
+    export class Music extends BytesizeIconComponent {}
+    export class Mute extends BytesizeIconComponent {}
+    export class Options extends BytesizeIconComponent {}
+    export class Paperclip extends BytesizeIconComponent {}
+    export class Pause extends BytesizeIconComponent {}
+    export class Photo extends BytesizeIconComponent {}
+    export class Plus extends BytesizeIconComponent {}
+    export class Minus extends BytesizeIconComponent {}
+    export class Play extends BytesizeIconComponent {}
+    export class Portfolio extends BytesizeIconComponent {}
+    export class Reload extends BytesizeIconComponent {}
+    export class Reply extends BytesizeIconComponent {}
+    export class Search extends BytesizeIconComponent {}
+    export class Settings extends BytesizeIconComponent {}
+    export class Star extends BytesizeIconComponent {}
+    export class Start extends BytesizeIconComponent {}
+    export class Tag extends BytesizeIconComponent {}
+    export class Trash extends BytesizeIconComponent {}
+    export class Twitter extends BytesizeIconComponent {}
+    export class Unlock extends BytesizeIconComponent {}
+    export class Upload extends BytesizeIconComponent {}
+    export class User extends BytesizeIconComponent {}
+    export class Video extends BytesizeIconComponent {}
+    export class Volume extends BytesizeIconComponent {}
+    export class Work extends BytesizeIconComponent {}
+}

react-color/react-color-tests.tsx

@@ -0,0 +1,54 @@
+// React Color Test
+// ================================================================================
+/// <reference path="react-color.d.ts"/>
+/// <reference path='../react/react.d.ts' />
+/// <reference path='../react/react-dom.d.ts' />
+
+// Imports
+// --------------------------------------------------------------------------------
+import * as React from "react"
+import { StatelessComponent } from "react"
+import { render } from "react-dom"
+import {
+    AlphaPicker, BlockPicker, ChromePicker, CirclePicker,
+    CompactPicker, GithubPicker, HuePicker, MaterialPicker,
+    PhotoshopPicker, SketchPicker, SliderPicker, SwatchesPicker,
+    TwitterPicker, CustomPicker
+} from "react-color"
+import { Alpha, Checkboard, EditableInput, Hue, Saturation } from "react-color/lib/components/common"
+
+interface CustomProps extends ReactColor.InjectedColorProps {
+    color?: ReactColor.Color
+}
+
+var CustomComponent: StatelessComponent<CustomProps> = (props: CustomProps) => {
+    function onChange (color: ReactColor.ColorResult) {}
+
+    return (
+        <div>
+            <Alpha color={ props.color } onChange={ onChange } />
+            <Checkboard size={ 10 } white="transparent" grey="#333" />
+            <EditableInput value={ props.color } label="Test" onChange={ onChange } />
+            <Hue color={ props.color } direction="horizontal" onChange={ onChange } />
+            <Saturation color={ props.color } onChange={ onChange } />
+        </div>
+    )
+}
+var Custom = CustomPicker(CustomComponent)
+
+var colors: Array<string> = ["#000", "#333"]
+
+render(<AlphaPicker height="100px" width="100px" />, document.getElementById("main"))
+render(<BlockPicker colors={ colors } width="100px" />, document.getElementById("main"))
+render(<ChromePicker disableAlpha />, document.getElementById("main"))
+render(<CirclePicker colors={ colors } width="100px" />, document.getElementById("main"))
+render(<CompactPicker colors={ colors } />, document.getElementById("main"))
+render(<GithubPicker colors={ colors } width="100px" />, document.getElementById("main"))
+render(<HuePicker height="100px" width="100px" />, document.getElementById("main"))
+render(<MaterialPicker />, document.getElementById("main"))
+render(<PhotoshopPicker header="Test" />, document.getElementById("main"))
+render(<SketchPicker disableAlpha presetColors={ colors } />, document.getElementById("main"))
+render(<SliderPicker />, document.getElementById("main"))
+render(<SwatchesPicker colors={ [colors] } height={ 100 } width={ 100 } />, document.getElementById("main"))
+render(<TwitterPicker />, document.getElementById("main"))
+render(<Custom />, document.getElementById("main"))

react-color/react-color.d.ts

@@ -0,0 +1,250 @@
+// Type definitions for react-color v2.3.4
+// Project: https://casesandberg.github.io/react-color/
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+///<reference path='../react/react.d.ts' />
+
+declare namespace ReactColor {
+    import React = __React
+
+    interface HSLColor {
+        a?: number
+        h: number
+        l: number
+        s: number
+    }
+
+    interface RGBColor {
+        a?: number
+        b: number
+        g: number
+        r: number
+    }
+
+    type Color = string | HSLColor | RGBColor
+
+    interface ColorResult {
+        hex: string
+        hsl: HSLColor
+        rgb: RGBColor
+    }
+
+    type ColorChangeHandler = (color: ColorResult) => void
+
+    interface ColorPickerProps<A> extends React.ClassAttributes<A> {
+        color?: Color
+        onChange?: ColorChangeHandler
+        onChangeComplete?: ColorChangeHandler
+    }
+
+    /* Predefined pickers */
+    interface AlphaPickerProps extends ColorPickerProps<AlphaPicker> {
+        height?: string
+        width?: string
+    }
+    interface AlphaPicker extends React.ComponentClass<AlphaPickerProps> {}
+    const AlphaPicker: AlphaPicker
+
+    interface BlockPickerProps extends ColorPickerProps<BlockPicker> {
+        colors?: Array<string>
+        width?: string
+    }
+    interface BlockPicker extends React.ComponentClass<BlockPickerProps> {}
+    const BlockPicker: BlockPicker
+
+    interface ChromePickerProps extends ColorPickerProps<ChromePicker> {
+        disableAlpha?: boolean
+    }
+    interface ChromePicker extends React.ComponentClass<ChromePickerProps> {}
+    const ChromePicker: ChromePicker
+
+    interface CirclePickerProps extends ColorPickerProps<CirclePicker> {
+        colors?: Array<string>
+        width?: string
+    }
+    interface CirclePicker extends React.ComponentClass<CirclePickerProps> {}
+    const CirclePicker: CirclePicker
+
+    interface CompactPickerProps extends ColorPickerProps<CompactPicker> {
+        colors?: Array<string>
+    }
+    interface CompactPicker extends React.ComponentClass<CompactPickerProps> {}
+    const CompactPicker: CompactPicker
+
+    interface GithubPickerProps extends ColorPickerProps<GithubPicker> {
+        colors?: Array<string>
+        width?: string
+    }
+    interface GithubPicker extends React.ComponentClass<GithubPickerProps> {}
+    const GithubPicker: GithubPicker
+
+    interface HuePickerProps extends ColorPickerProps<HuePicker> {
+        height?: string
+        width?: string
+    }
+    interface HuePicker extends React.ComponentClass<HuePickerProps> {}
+    const HuePicker: HuePicker
+
+    interface MaterialPickerProps extends ColorPickerProps<MaterialPicker> {}
+    interface MaterialPicker extends React.ComponentClass<MaterialPickerProps> {}
+    const MaterialPicker: MaterialPicker
+
+    interface PhotoshopPickerProps extends ColorPickerProps<PhotoshopPicker> {
+        header?: string
+        onAccept?: ColorChangeHandler
+        onCancel?: ColorChangeHandler
+    }
+    interface PhotoshopPicker extends React.ComponentClass<PhotoshopPickerProps> {}
+    const PhotoshopPicker: PhotoshopPicker
+
+    interface SketchPickerProps extends ColorPickerProps<SketchPicker> {
+        disableAlpha?: boolean
+        presetColors?: Array<string>
+        width?: string
+    }
+    interface SketchPicker extends React.ComponentClass<SketchPickerProps> {}
+    const SketchPicker: SketchPicker
+
+    interface SliderPickerProps extends ColorPickerProps<SliderPicker> {}
+    interface SliderPicker extends React.ComponentClass<SliderPickerProps> {}
+    const SliderPicker: SliderPicker
+
+    interface SwatchesPickerProps extends ColorPickerProps<SwatchesPicker> {
+        colors?: Array<Array<string>>
+        height?: number
+        width?: number
+    }
+    interface SwatchesPicker extends React.ComponentClass<SwatchesPickerProps> {}
+    const SwatchesPicker: SwatchesPicker
+
+    interface TwitterPickerProps extends ColorPickerProps<TwitterPicker> {}
+    interface TwitterPicker extends React.ComponentClass<TwitterPickerProps> {}
+    const TwitterPicker: TwitterPicker
+
+    /* For custom picker */
+    interface InjectedColorProps {
+        hex?: string
+        hsl?: HSLColor
+        rgb?: RGBColor
+        onChange?: ColorChangeHandler
+    }
+
+    function CustomPicker<A>(component: React.ComponentClass<A> | React.StatelessComponent<A>): React.ComponentClass<A & InjectedColorProps>
+
+    interface CustomPickerProps<A> extends React.ClassAttributes<A> {
+        color?: Color
+        pointer?: React.ReactNode
+        onChange?: ColorChangeHandler
+    }
+
+    interface AlphaProps extends CustomPickerProps<Alpha> {}
+    interface Alpha extends React.ComponentClass<AlphaProps> {}
+    const Alpha: Alpha
+
+    interface EditableInputStyles {
+        input?: React.CSSProperties
+        label?: React.CSSProperties
+        wrap?: React.CSSProperties
+    }
+    interface EditableInputProps extends React.ClassAttributes<Alpha> {
+        color?: Color
+        label?: string
+        onChange?: ColorChangeHandler
+        styles?: EditableInputStyles
+        value?: any
+    }
+    interface EditableInput extends React.ComponentClass<EditableInputProps> {}
+    const EditableInput: EditableInput
+
+    interface HueProps extends CustomPickerProps<Hue> {
+        direction?: "horizontal" | "vertical"
+    }
+    interface Hue extends React.ComponentClass<HueProps> {}
+    const Hue: Hue
+
+    interface SaturationProps extends CustomPickerProps<Saturation> {}
+    interface Saturation extends React.ComponentClass<SaturationProps> {}
+    const Saturation: Saturation
+
+    interface CheckboardProps extends React.ClassAttributes<Checkboard> {
+        grey?: string
+        size?: number
+        white?: string
+    }
+    interface Checkboard extends React.ComponentClass<CheckboardProps> {}
+    const Checkboard: Checkboard
+}
+
+declare module "react-color/lib/components/common/Alpha" { export default ReactColor.Alpha }
+declare module "react-color/lib/components/common/Checkboard" { export default ReactColor.Checkboard }
+declare module "react-color/lib/components/common/EditableInput" { export default ReactColor.EditableInput }
+declare module "react-color/lib/components/common/Hue" { export default ReactColor.Hue }
+declare module "react-color/lib/components/common/Saturation" { export default ReactColor.Saturation }
+declare module "react-color/lib/components/common/ColorWrap" { export default ReactColor.CustomPicker }
+
+declare module "react-color/lib/components/common" {
+    import Alpha from "react-color/lib/components/common/Alpha"
+    import Checkboard from "react-color/lib/components/common/Checkboard"
+    import EditableInput from "react-color/lib/components/common/EditableInput"
+    import Hue from "react-color/lib/components/common/Hue"
+    import Saturation from "react-color/lib/components/common/Saturation"
+
+    export {
+        Alpha,
+        Checkboard,
+        EditableInput,
+        Hue,
+        Saturation
+    }
+}
+
+declare module "react-color/lib/components/alpha/Alpha" { export default ReactColor.AlphaPicker }
+declare module "react-color/lib/components/block/Block" { export default ReactColor.BlockPicker }
+declare module "react-color/lib/components/chrome/Chrome" { export default ReactColor.ChromePicker }
+declare module "react-color/lib/components/circle/Circle" { export default ReactColor.CirclePicker }
+declare module "react-color/lib/components/compact/Compact" { export default ReactColor.CompactPicker }
+declare module "react-color/lib/components/github/Github" { export default ReactColor.GithubPicker }
+declare module "react-color/lib/components/hue/Hue" { export default ReactColor.HuePicker }
+declare module "react-color/lib/components/meterial/Material" { export default ReactColor.MaterialPicker }
+declare module "react-color/lib/components/photoshop/Photoshop" { export default ReactColor.PhotoshopPicker }
+declare module "react-color/lib/components/sketch/Sketch" { export default ReactColor.SketchPicker }
+declare module "react-color/lib/components/slider/Slider" { export default ReactColor.SliderPicker }
+declare module "react-color/lib/components/swatches/Swatches" { export default ReactColor.SwatchesPicker }
+declare module "react-color/lib/components/twitter/Twitter" { export default ReactColor.TwitterPicker }
+
+declare module "react-color" {
+    import AlphaPicker from "react-color/lib/components/alpha/Alpha"
+    import BlockPicker from "react-color/lib/components/block/Block"
+    import ChromePicker from "react-color/lib/components/chrome/Chrome"
+    import CirclePicker from "react-color/lib/components/circle/Circle"
+    import CompactPicker from "react-color/lib/components/compact/Compact"
+    import GithubPicker from "react-color/lib/components/github/Github"
+    import HuePicker from "react-color/lib/components/hue/Hue"
+    import MaterialPicker from "react-color/lib/components/meterial/Material"
+    import PhotoshopPicker from "react-color/lib/components/photoshop/Photoshop"
+    import SketchPicker from "react-color/lib/components/sketch/Sketch"
+    import SliderPicker from "react-color/lib/components/slider/Slider"
+    import SwatchesPicker from "react-color/lib/components/swatches/Swatches"
+    import TwitterPicker from "react-color/lib/components/twitter/Twitter"
+    import CustomPicker from "react-color/lib/components/common/ColorWrap"
+
+    export type CustomPickerProps<A> = ReactColor.CustomPickerProps<A>
+
+    export {
+        AlphaPicker,
+        BlockPicker,
+        ChromePicker,
+        CirclePicker,
+        CompactPicker,
+        GithubPicker,
+        HuePicker,
+        MaterialPicker,
+        PhotoshopPicker,
+        SketchPicker,
+        SliderPicker,
+        SwatchesPicker,
+        TwitterPicker,
+        CustomPicker
+    }
+}

react-css-transition-replace/react-css-transition-replace-tests.tsx

@@ -0,0 +1,18 @@
+// React CSS Transition Replace Test
+// ================================================================================
+///<reference path="react-css-transition-replace.d.ts"/>
+///<reference path="../react/react.d.ts"/>
+///<reference path="../react/react-dom.d.ts"/>
+
+// Imports
+// --------------------------------------------------------------------------------
+import * as React from "react"
+import { render } from 'react-dom';
+import * as CSSTransitionReplace from "react-css-transition-replace"
+
+render(
+    <CSSTransitionReplace overflowHidden transitionName="test">
+        <div>Test</div>
+    </CSSTransitionReplace>,
+    document.getElementById("main")
+)

react-css-transition-replace/react-css-transition-replace.d.ts

@@ -0,0 +1,23 @@
+// Type definitions for react-css-transition-replace 2.0.1
+// Project: http://marnusw.github.io/react-css-transition-replace/
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../react/react.d.ts" />
+/// <reference path="../react/react-addons-css-transition-group.d.ts" />
+
+declare namespace TransitionReplace {
+    import React = __React
+
+    interface CSSTransitionReplaceProps extends React.CSSTransitionGroupProps {
+        overflowHidden?: boolean
+    }
+
+    type CSSTransitionReplace = React.ComponentClass<CSSTransitionReplaceProps>
+}
+
+declare module "react-css-transition-replace" {
+    var CSSTransitionReplace: TransitionReplace.CSSTransitionReplace
+    type CSSTransitionReplace = TransitionReplace.CSSTransitionReplace
+    export = CSSTransitionReplace
+}

react-fa/index.d.ts

@@ -6,22 +6,30 @@
 /// <reference types="react" />
 
 
-import { ComponentClass, Props } from 'react';
+import { Component, ClassAttributes  } from 'react';
 
-interface IconProps extends Props<Icon> {
-    name: string;
-    className?: string;
-    size?: string;
-    spin?: boolean;
-    rotate?: string;
-    flip?: string;
-    fixedWidth?: boolean;
-    pulse?: boolean;
-    stack?: string;
-    inverse?: boolean;
+type IconSize = "lg" | "2x" | "3x" | "4x" | "5x"
+
+interface IconProps extends ClassAttributes<Icon> {
+    name: string
+    className?: string
+    size?: IconSize
+    rotate?: "45" | "90" | "135" | "180" | "225" | "270" | "315"
+    flip?: "horizontal" | "vertical"
+    fixedWidth?: boolean
+    spin?: boolean
+    pulse?: boolean
+    stack?: "1x" | "2x"
+    inverse?: boolean
+    Component?: string | Function
 }
 
-interface Icon extends ComponentClass<IconProps> { }
-declare const Icon: Icon;
+export class Icon extends Component<IconProps, {}> {}
 
-export = Icon;
+interface IconStackProps extends ClassAttributes<IconStack> {
+    className?: string
+    size?: IconSize
+}
+export class IconStack extends Component<IconStackProps, {}> {}
+
+export default Icon;

react-fa/react-fa-4.0.0.d.ts

@@ -0,0 +1,28 @@
+// Type definitions for react-fa v4.0.0
+// Project: https://github.com/andreypopp/react-fa
+// Definitions by: Frank Laub <https://github.com/flaub>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../react/react.d.ts" />
+
+declare module "react-fa" {
+	import { ComponentClass, Props } from 'react';
+
+	interface IconProps extends Props<Icon> {
+		name: string;
+		className?: string;
+		size?: string;
+		spin?: boolean;
+		rotate?: string;
+		flip?: string;
+		fixedWidth?: boolean;
+		pulse?: boolean;
+		stack?: string;
+		inverse?: boolean;
+	}
+
+	interface Icon extends ComponentClass<IconProps> { }
+	const Icon: Icon;
+
+	export = Icon;
+}

react-fa/react-fa-tests.tsx

@@ -1,10 +1,20 @@
 /// <reference types="react-dom"/>
 
-import * as React from "react";
-import { render } from 'react-dom';
-import Icon = require('react-fa');
+// Imports
+// --------------------------------------------------------------------------------
+import * as React from "react"
+import { render } from "react-dom"
+import { Icon, IconStack } from "react-fa"
 
 render(
-	<Icon spin name="spinner" />,
-	document.getElementById('main')
+	<Icon spin name="spinner" rotate="90" size="2x" Component="span" />,
+	document.getElementById("main")
+)
+
+render(
+	<IconStack size="2x">
+		<Icon name="test" stack="2x" />
+		<Icon name="test" stack="1x" />
+	</IconStack>,
+	document.getElementById("main")
 )

react-ga/index.d.ts

@@ -16,10 +16,15 @@ declare namespace __reactGA {
         debug?: boolean;
     }
 
+    export interface FieldsObject {
+        [i: string]: any;
+    }
+
     export function initialize(trackingCode: string, options?: InitializeOptions): void;
     export function pageview(path: string): void;
     export function modalview(name: string): void;
     export function event(args: EventArgs): void;
+    export function set(fieldsObject: FieldsObject): void;
 }
 
 declare module 'react-ga' {

react-ga/react-ga-tests.tsx

@@ -8,11 +8,11 @@ describe("Testing react-ga initialize object", () => {
     });
     it("Able to initailize react-ga object", () => {
         let ga = __reactGA;
-        
+
         let options: __reactGA.InitializeOptions = {
             debug: true,
         }
-        
+
         ga.initialize("UA-65432-1", options);
     });
 });
@@ -21,7 +21,7 @@ describe("Testing react-ga pageview calls", () => {
     it("Able to make pageview calls", () => {
         let ga = __reactGA;
         ga.initialize("UA-65432-1");
-        
+
         ga.pageview("http://telshin.com");
     });
 });
@@ -30,7 +30,7 @@ describe("Testing react-ga modal calls", () => {
     it("Able to make modal calls", () => {
         let ga = __reactGA;
         ga.initialize("UA-65432-1");
-        
+
         ga.modalview("Test modal");
     });
 });
@@ -39,7 +39,7 @@ describe("Testing react-ga event calls", () => {
     it("Able to make event calls", () => {
         let ga = __reactGA;
         ga.initialize("UA-65432-1");
-        
+
         let options: __reactGA.EventArgs = {
             category: "Test",
             action: "CI",
@@ -47,7 +47,20 @@ describe("Testing react-ga event calls", () => {
             value: 4,
             nonInteraction: true,
         }
-        
+
         ga.event(options);
     });
-});
+});
+
+describe("Testing react-ga set calls", () => {
+    it("Able to make set calls", () => {
+        let ga = __reactGA;
+        ga.initialize("UA-65432-1");
+
+        let fieldObject: __reactGA.FieldsObject = {
+            page: '/users'
+        };
+
+        ga.set(fieldObject);
+    });
+});

react-intl-redux/react-intl-redux-tests.tsx

@@ -0,0 +1,28 @@
+// React Intl Redux Test
+// ================================================================================
+/// <reference path="react-intl-redux.d.ts"/>
+/// <reference path="../react/react.d.ts"/>
+/// <reference path="../react/react-dom.d.ts"/>
+
+// Imports
+// --------------------------------------------------------------------------------
+import * as React from "react"
+import { render } from "react-dom"
+import { Provider, IntlProvider, IntlState, IntlAction, intlReducer, updateIntl } from "react-intl-redux"
+
+var action: IntlAction = updateIntl({ locale : "en", messages : {} })
+var state: IntlState = intlReducer({ locale : "en", messages : {} }, action)
+
+render(
+    <IntlProvider locale="en">
+        <div>Test</div>
+    </IntlProvider>,
+    document.getElementById("main")
+)
+
+render(
+    <Provider>
+        <div>Test</div>
+    </Provider>,
+    document.getElementById("main")
+)

react-intl-redux/react-intl-redux.d.ts

@@ -0,0 +1,28 @@
+// Type definitions for react-intl-redux v0.1.0
+// Project: https://github.com/ratson/react-intl-redux
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../react/react.d.ts" />
+/// <reference path="../react-redux/react-redux.d.ts" />
+/// <reference path="../react-intl/react-intl.d.ts" />
+
+declare module "react-intl-redux" {
+    import { Action } from "redux"
+    import { Provider as ReduxProvider } from "react-redux"
+    import { IntlProvider as ReactIntlProvider } from "react-intl"
+
+    interface IntlState {
+        locale: string
+        messages: any
+    }
+
+    interface IntlAction extends Action {
+        payload?: IntlState
+    }
+
+    export function intlReducer(state: IntlState, action: IntlAction): IntlState
+    export function updateIntl (opts: IntlState): IntlAction
+    export class IntlProvider extends ReactIntlProvider {}
+    export class Provider extends ReduxProvider {}
+}

react-native-sortable-list/react-native-sortable-list-tests.tsx

@@ -0,0 +1,208 @@
+/// <reference path="../react/react.d.ts"/>
+/// <reference path="../react-native/react-native.d.ts"/>
+/// <reference path="react-native-sortable-list.d.ts" />
+
+import * as React from 'react';
+import {
+    Animated,
+    Easing,
+    AppRegistry,
+    StyleSheet,
+    Text,
+    Image,
+    View,
+    Dimensions,
+    FlexJustifyType,
+    FlexAlignType
+} from 'react-native';
+import SortableList, {RowProps} from 'react-native-sortable-list';
+
+
+const window = Dimensions.get('window');
+
+const data = {
+    0: {
+        image: 'https://placekitten.com/200/200',
+        text: 'Chloe',
+    },
+    1: {
+        image: 'https://placekitten.com/200/201',
+        text: 'Jasper',
+    },
+    2: {
+        image: 'https://placekitten.com/200/202',
+        text: 'Pepper',
+    },
+    3: {
+        image: 'https://placekitten.com/200/203',
+        text: 'Oscar',
+    },
+    4: {
+        image: 'https://placekitten.com/200/204',
+        text: 'Dusty',
+    },
+    5: {
+        image: 'https://placekitten.com/200/205',
+        text: 'Spooky',
+    },
+    6: {
+        image: 'https://placekitten.com/200/210',
+        text: 'Kiki',
+    },
+    7: {
+        image: 'https://placekitten.com/200/215',
+        text: 'Smokey',
+    },
+    8: {
+        image: 'https://placekitten.com/200/220',
+        text: 'Gizmo',
+    },
+    9: {
+        image: 'https://placekitten.com/220/239',
+        text: 'Kitty',
+    },
+};
+
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        justifyContent: "center" as FlexJustifyType,
+        alignItems: "center" as FlexAlignType,
+        backgroundColor: '#eee',
+        paddingTop: 60,
+    },
+
+    list: {
+        flex: 1,
+    },
+
+    contentContainer: {
+        width: window.width,
+        paddingHorizontal: 30,
+    },
+
+    row: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        backgroundColor: 'white',
+        padding: 16,
+        marginVertical: 5,
+        height: 90,
+        width: window.width - 30 * 2,
+        borderRadius: 4,
+        shadowColor: 'rgba(0,0,0,0.2)',
+        shadowOpacity: 1,
+        shadowOffset: {height: 2, width: 2},
+        shadowRadius: 2,
+    },
+
+    image: {
+        width: 60,
+        height: 60,
+        marginRight: 30,
+        borderRadius: 30,
+    },
+
+    text: {
+        fontSize: 24,
+    },
+
+});
+
+class Basic extends React.Component<void, void> {
+    render() {
+        return (
+            <View style={styles.container}>
+                <SortableList
+                    style={styles.list}
+                    contentContainerStyle={styles.contentContainer}
+                    data={data}
+                    renderRow={this._renderRow}/>
+            </View>
+        );
+    }
+
+    _renderRow = ({data, active}: RowProps) => {
+        return <Row data={data} active={active}/>
+    }
+}
+
+interface RowState {
+    style: {
+        shadowRadius: Animated.Value
+        transform: {scale: Animated.Value}[]
+    }
+}
+
+class Row extends React.Component<RowProps, RowState> {
+
+    state = {
+        style: {
+            shadowRadius: new Animated.Value(2),
+            transform: [{scale: new Animated.Value(1)}],
+        }
+    };
+
+    componentWillReceiveProps(nextProps: RowProps) {
+        if (this.props.active !== nextProps.active) {
+            if (this.props.active !== nextProps.active) {
+                if (nextProps.active) {
+                    this.startActivationAnimation();
+                } else {
+                    this.startDeactivationAnimation();
+                }
+            }
+        }
+    }
+
+    startActivationAnimation = () => {
+        const {style} = this.state;
+
+        Animated.parallel([
+            Animated.timing(style.transform[0].scale, {
+                duration: 100,
+                easing: Easing.out(Easing.quad),
+                toValue: 1.1
+            }),
+            Animated.timing(style.shadowRadius, {
+                duration: 100,
+                easing: Easing.out(Easing.quad),
+                toValue: 10
+            }),
+        ]).start();
+    };
+
+    startDeactivationAnimation = () => {
+        const {style} = this.state;
+
+        Animated.parallel([
+            Animated.timing(style.transform[0].scale, {
+                duration: 100,
+                easing: Easing.out(Easing.quad),
+                toValue: 1
+            }),
+            Animated.timing(style.shadowRadius, {
+                duration: 100,
+                easing: Easing.out(Easing.quad),
+                toValue: 2
+            }),
+        ]).start();
+    };
+
+    render() {
+        const {data} = this.props;
+
+        return (
+            <Animated.View style={[
+                styles.row,
+                this.state.style,
+    ]}>
+                <Image source={{uri: data.image}} style={styles.image}/>
+                <Text style={styles.text}>{data.text}</Text>
+            </Animated.View>
+        );
+    }
+}
+
+
+AppRegistry.registerComponent('Basic', () => Basic);

react-native-sortable-list/react-native-sortable-list.d.ts

@@ -0,0 +1,99 @@
+// Type definitions for react-native-sortable-list
+// Project: https://github.com/gitim/react-native-sortable-list
+// Definitions by: Michael Sivolobov <https://github.com/sivolobov>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../react/react.d.ts"/>
+/// <reference path="../react-native/react-native.d.ts"/>
+
+declare namespace __SortableList {
+
+    type DataKey = string | number;
+
+    export type DataValue = any
+
+    type DataByNumber = {
+        [key: number]: DataValue
+    }
+
+    type DataByString = {
+        [key: string]: DataValue
+    }
+
+    export type Data = DataByNumber | DataByString;
+
+    export interface RowProps {
+        active: boolean
+        data: DataValue
+        key?: DataKey
+        index?: number
+        disabled?: boolean
+    }
+
+    interface SortableListProps {
+
+        /**
+         * data source
+         */
+        data: Data
+
+        /**
+         * an array of keys from data, the order of keys from the array will be used to initial rows order
+         */
+        order?: DataKey[]
+
+        /**
+         * style of HOC
+         */
+        style?: React.ViewStyle
+
+        /**
+         * these styles will be applied to the inner scroll view content container
+         */
+        contentContainerStyle?: React.ViewStyle
+
+        /**
+         * when false, rows are not sortable. The default value is true.
+         */
+        sortingEnabled?: boolean
+
+        /**
+         * when false, the content does not scrollable. The default value is true.
+         */
+        scrollEnabled?: boolean
+
+        /**
+         * Takes a row key, row index, data entry from the data source and its statuses disabled,
+         *  active and should return a renderable component to be rendered as the row.
+         */
+        renderRow: (props: RowProps) => JSX.Element
+
+        /**
+         * Called when rows were reordered, takes an array of rows keys of the next rows order.
+         */
+        onChangeOrder?: (nextOrder: DataKey[]) => void
+
+        /**
+         * Called when a row was activated (user long tapped).
+         */
+        onActivateRow?: (key: DataKey) => void
+
+        /**
+         * Called when the active row was released.
+         */
+        onReleaseRow?: (key: DataKey) => void
+    }
+
+    export interface SortableListStatic extends React.ClassicComponentClass<SortableListProps> {}
+
+    export var SortableList: SortableListStatic;
+    export type SortableList = SortableListStatic;
+}
+
+declare module 'react-native-sortable-list' {
+    import SortableList = __SortableList;
+
+    export interface RowProps extends SortableList.RowProps {}
+
+    export default SortableList.SortableList;
+}

react-native-sortable-list/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "compilerOptions": {
+        "target": "es6",
+        "noImplicitAny": true
+    }
+}

react-native/index.d.ts

@@ -7616,11 +7616,16 @@ declare module "react" {
 
     export interface NavigationHeaderProps {
         renderTitleComponent?(props: Object): JSX.Element
+        renderLeftComponent?(props: Object): JSX.Element
+        renderRightComponent?(props: Object): JSX.Element
         onNavigateBack(): void
+        style?: ViewStyle
+        viewProps?: any
+        statusBarHeight?: number | NavigationAnimatedValue
     }
 
     export interface NavigationHeaderStatic extends React.ComponentClass<NavigationHeaderProps> {
-        Title: JSX.Element
+        Title: () => JSX.ElementClass
         HEIGHT: number
     }
 

react-onclickoutside/react-onclickoutside-tests.tsx

@@ -0,0 +1,46 @@
+// React onClickOutside Test
+// ================================================================================
+/// <reference path="react-onclickoutside.d.ts"/>
+/// <reference path='../react/react.d.ts' />
+/// <reference path='../react/react-dom.d.ts' />
+
+// Imports
+// --------------------------------------------------------------------------------
+import * as React from "react"
+import { Component, StatelessComponent, MouseEvent } from "react"
+import { render } from "react-dom"
+import * as onClickOutside from "react-onclickoutside"
+
+interface TestProps extends ReactOnClickOutside.OnClickOutsideProps {}
+
+var TestStateless: StatelessComponent<TestProps> = (props: TestProps) => {
+    return (<div>Test</div>)
+}
+var TestStatelessWrapped = onClickOutside(TestStateless)
+
+class Test extends Component<TestProps, any> implements ReactOnClickOutside.OnClickOutsideComponent {
+    handleClickOutside (e: MouseEvent) {}
+
+    render () {
+        return (<div>Test</div>)
+    }
+}
+var TestWrapped = onClickOutside(Test)
+
+render(
+    <TestStatelessWrapped eventTypes="click"
+                          disableOnClickOutside
+                          preventDefault
+                          stopPropagation
+                          outsideClickIgnoreClass="ignore" />,
+    document.getElementById("main")
+)
+
+render(
+    <TestWrapped eventTypes={ ["click", "touchend"] }
+                 disableOnClickOutside
+                 preventDefault
+                 stopPropagation
+                 outsideClickIgnoreClass="ignore" />,
+    document.getElementById("main")
+)

react-onclickoutside/react-onclickoutside.d.ts

@@ -0,0 +1,32 @@
+// Type definitions for react-onclickoutside v5.7.0
+// Project: https://github.com/Pomax/react-onclickoutside
+// Definitions by: Karol Janyst <https://github.com/LKay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+///<reference path='../react/react.d.ts' />
+
+declare namespace ReactOnClickOutside {
+    import React = __React
+
+    interface OnClickOutsideComponent {
+        handleClickOutside(e: React.MouseEvent): void
+    }
+
+    interface OnClickOutsideProps {
+        disableOnClickOutside?: boolean | Function
+        enableOnClickOutside?: Function
+        eventTypes?: string | Array<string>
+        outsideClickIgnoreClass?: string
+        preventDefault?: boolean
+        stopPropagation?: boolean
+    }
+
+    interface onClickOutside {
+        <A>(component: React.ComponentClass<A> | React.StatelessComponent<A>): React.ComponentClass<A & OnClickOutsideProps>
+    }
+}
+
+declare module "react-onclickoutside" {
+    const onClickOutside: ReactOnClickOutside.onClickOutside
+    export = onClickOutside
+}