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

.gitignore

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

CONTRIBUTORS.md

@@ -1665,7 +1665,8 @@ This document generated by [dt-contributors-generator](https://github.com/vvakam
 * [:link:](supertest/supertest.d.ts) [SuperTest](https://github.com/visionmedia/supertest) by [Alex Varju](https://github.com/varju)
 * [:link:](supertest-as-promised/supertest-as-promised.d.ts) [SuperTest as Promised](https://github.com/WhoopInc/supertest-as-promised) by [Tanguy Krotoff](https://github.com/tkrotoff)
 * [:link:](svg-injector/svg-injector.d.ts) [SVG Injector](https://github.com/iconic/SVGInjector) by [Patrick Westerhoff](https://github.com/poke)
-* [:link:](svg-pan-zoom/svg-pan-zoom.d.ts) [svg-pan-zoom](https://github.com/ariutta/svg-pan-zoom) by [Chintan Shah](https://github.com/Promact)
+* [:link:](svg-pan-zoom/svg-pan-zoom-2.3.9.d.ts) [svg-pan-zoom](https://github.com/ariutta/svg-pan-zoom) by [Chintan Shah](https://github.com/Promact)
+* [:link:](svg-pan-zoom/svg-pan-zoom.d.ts) [svg-pan-zoom](https://github.com/ariutta/svg-pan-zoom) by [César Vidril](https://github.com/Yimiprod)
 * [:link:](svg-sprite/svg-sprite.d.ts) [svg-sprite](https://github.com/jkphl/svg-sprite) by [Qubo](https://github.com/tkqubo)
 * [:link:](svgjs/svgjs.d.ts) [svg.js](http://www.svgjs.com) by [Sean Hess](https://seanhess.github.io)
 * [:link:](svg2png/svg2png.d.ts) [svg2png node package](https://github.com/domenic/svg2png) by [hans windhoff](https://github.com/hansrwindhoff)

PULL_REQUEST_TEMPLATE.md

@@ -13,5 +13,5 @@ If adding a new definition:
 - [ ] Include the required [files](https://github.com/DefinitelyTyped/DefinitelyTyped#create-a-new-package) and header. Base these on the README, *not* on an existing project.
 
 If changing an existing definition:
-- [ ] Provide a URL to  documentation or source code which provides context for the suggested changes: <<url here>>
+- [ ] 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

@@ -52,21 +52,26 @@ DefinitelyTyped only works because of contributions by users like you!
 
 Before you share your improvement with the world, use it yourself.
 
-#### Test editing an exiting package
+#### Test editing an existing package
 
 To add new features you can use [module augmentation](http://www.typescriptlang.org/docs/handbook/declaration-merging.html).
-You can also directly edit the types in `node_modules/@types/foo/index.d.ts`,
-or copy them from there and paste inside of `declarations.d.ts` and follow the steps below.
+You can also directly edit the types in `node_modules/@types/foo/index.d.ts`, or copy them from there and follow the steps below.
 
 
 #### Test a new package
 
-* Add a new file `declarations.d.ts` to your project.
-* Add it to the compilation, through `"includes"` or `"files"` in your [tsconfig](http://www.typescriptlang.org/docs/handbook/tsconfig-json.html),
-or through a `/// <reference path="" />` declaration in your code.
-* Inside `declarations.d.ts`, write `declare module "foo" { }`, then write the module declaration inside.
-* Test that your code works.
-* *Then*, once you've tested your definitions, make a PR contributing the definition.
+Add to your `tsconfig.json`:
+
+```json
+"baseUrl": "types",
+"typeRoots": ["types"],
+```
+
+(You can also use `src/types`.)
+Create `types/foo/index.d.ts` containing declarations for the module "foo".
+You should now be able import from `"foo"` in your code and it will route to the new type definition.
+Then build *and* run the code to make sure your type definition actually corresponds to what happens at runtime.
+Once you've tested your definitions with real code, make a PR contributing the definition by copying `types/foo` to `DefinitelyTyped/foo` and adding a `tsconfig.json` and `foo-tests.ts`.
 
 
 ### Make a pull request
@@ -95,7 +100,7 @@ If it doesn't, you can do so yourself in the comment associated with the PR.
 
 #### Create a new package
 
-If you are the library author, or can make a pull request to the library, [bundle](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) types instead of publishing to DefinitelyTyped.
+If you are the library author, or can make a pull request to the library, [bundle types](http://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html) instead of publishing to DefinitelyTyped.
 
 If you are adding typings for an NPM package, create a directory with the same name.
 If the package you are adding typings for is not on NPM, make sure the name you choose for it does not conflict with the name of a package on NPM.
@@ -108,6 +113,7 @@ Your package should have this structure:
 | index.d.ts | This contains the typings for the package. |
 | foo-tests.ts | This contains sample code which tests the typings. This code does *not* run, but it is type-checked. |
 | tsconfig.json | This allows you to run `tsc` within the package. |
+| tslint.json | Enables linting. |
 
 Generate these by running `npm run new-package -- new-package-name`.
 
@@ -125,7 +131,7 @@ For a good example package, see [base64-js](https://github.com/DefinitelyTyped/D
 * `interface X {}`: An empty interface is essentially the `{}` type: it places no constraints on an object.
 * `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(); }
+    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 {}`:
@@ -187,7 +193,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 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="" />`.
+If the module you're referencing is an ambient module (uses `declare module`, or just declares globals), use `<reference types="" />`.
 
 #### What do I do about older versions of typings?
 

accepts/accepts-tests.ts

@@ -0,0 +1,25 @@
+import accepts = require("accepts");
+
+const req: any = {};
+
+const accept = accepts(req);
+
+const charsets = accept.charsets();
+const charsetFromEmpty = accept.charset();
+const charsetFromParams = accept.charset("json", "text");
+const charsetFromArray = accept.charset(["json", "text"]);
+
+const encodings = accept.encodings();
+const encodingFromEmpty = accept.encoding();
+const encodingFromParams = accept.encoding("json", "text");
+const encodingFromArray = accept.encoding(["json", "text"]);
+
+const languages = accept.languages();
+const languageFromEmpty = accept.language();
+const languageFromParams = accept.language("json", "text");
+const languageFromArray = accept.language(["json", "text"]);
+
+const types = accept.types();
+const typeFromEmpty = accept.type();
+const typeFromParams = accept.type("json", "text");
+const typeFromArray = accept.type(["json", "text"]);

accepts/index.d.ts

@@ -0,0 +1,31 @@
+// Type definitions for accepts 1.3
+// Project: https://github.com/jshttp/accepts
+// Definitions by: Stefan Reichel <https://github.com/bomret>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+
+declare namespace accepts {
+    export interface Accepts {
+        charset(charsets: string[]): string | string[] | boolean;
+        charset(...charsets: string[]): string | string[] | boolean;
+        charsets(): string[];
+
+        encoding(encodings: string[]): string | string[] | boolean;
+        encoding(...encodings: string[]): string | string[] | boolean;
+        encodings(): string[];
+
+        language(languages: string[]): string | string[] | boolean;
+        language(...languages: string[]): string | string[] | boolean;
+        languages(): string[];
+
+        type(types: string[]): string | string[] | boolean;
+        type(...types: string[]): string | string[] | boolean;
+        types(): string[];
+    }
+}
+
+declare function accepts(req: IncomingMessage): accepts.Accepts;
+
+export = accepts;

accepts/tsconfig.json

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

accepts/tslint.json

@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

accounting/index.d.ts

@@ -3,77 +3,72 @@
 // Definitions by: Sergey Gerasimov <https://github.com/gerich-home/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface IAccountingCurrencyFormat {
-    pos: string;         // for positive values, eg. "$ 1.00"
-	neg?: string;        // for negative values, eg. "$ (1.00)"
-	zero?: string;       // for zero values, eg. "$  --"
+declare namespace accounting {
+    interface IAccountingCurrencyFormat {
+        pos: string;         // for positive values, eg. "$ 1.00"
+        neg?: string;        // for negative values, eg. "$ (1.00)"
+        zero?: string;       // for zero values, eg. "$  --"
+    }
+
+    interface IAccountingCurrencySettings<TFormat> {
+        symbol?: string;     // default currency symbol is '$'
+        format?: TFormat;    // controls output: %s = symbol, %v = value/number
+        decimal?: string;    // decimal point separator
+        thousand?: string;   // thousands separator
+        precision?: number;   // decimal places
+    }
+
+    interface IAccountingNumberSettings {
+        precision?: number;  // default precision on numbers is 0
+        thousand?: string;
+        decimal?: string;
+    }
+
+    interface IAccountingSettings {
+        currency: IAccountingCurrencySettings<any>; // IAccountingCurrencySettings<string> or IAccountingCurrencySettings<IAccountingCurrencyFormat>
+        number: IAccountingNumberSettings;
+    }
+
+    interface IAccountingStatic {
+        // format any number into currency
+        formatMoney(number: number, symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string;
+        formatMoney(number: number, options: IAccountingCurrencySettings<string> | IAccountingCurrencySettings<IAccountingCurrencyFormat>): string;
+
+        formatMoney(numbers: number[], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string[];
+        formatMoney(numbers: number[], options: IAccountingCurrencySettings<string> | IAccountingCurrencySettings<IAccountingCurrencyFormat>): string[];
+
+        // generic case (any array of numbers)
+        formatMoney(numbers: any[], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): any[];
+        formatMoney(numbers: any[], options: IAccountingCurrencySettings<string> | IAccountingCurrencySettings<IAccountingCurrencyFormat>): any[];
+
+        // format a list of values for column-display
+        formatColumn(numbers: number[], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string[];
+        formatColumn(numbers: number[], options: IAccountingCurrencySettings<string> | IAccountingCurrencySettings<IAccountingCurrencyFormat>): string[];
+
+        formatColumn(numbers: number[][], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string[][];
+        formatColumn(numbers: number[][], options: IAccountingCurrencySettings<string> | IAccountingCurrencySettings<IAccountingCurrencyFormat>): string[][];
+
+        // format a number with custom precision and localisation
+        formatNumber(number: number, precision?: number, thousand?: string, decimal?: string): string;
+        formatNumber(number: number, options: IAccountingNumberSettings): string;
+
+        formatNumber(number: number[], precision?: number, thousand?: string, decimal?: string): string[];
+        formatNumber(number: number[], options: IAccountingNumberSettings): string[];
+
+        formatNumber(number: any[], precision?: number, thousand?: string, decimal?: string): any[];
+        formatNumber(number: any[], options: IAccountingNumberSettings): any[];
+
+        // better rounding for floating point numbers
+        toFixed(number: number, precision?: number): string;
+
+        // get a value from any formatted number/currency string
+        unformat(string: string, decimal?: string): number;
+
+        // settings object that controls default parameters for library methods
+        settings: IAccountingSettings;
+    }
 }
 
-interface IAccountingCurrencySettings<TFormat> {
-    symbol?: string;     // default currency symbol is '$'
-    format?: TFormat;    // controls output: %s = symbol, %v = value/number
-    decimal?: string;    // decimal point separator
-    thousand?: string;   // thousands separator
-    precision?: number   // decimal places
-}
-
-interface IAccountingNumberSettings {
-    precision?: number;  // default precision on numbers is 0
-    thousand?: string;
-    decimal?: string;
-}
-
-interface IAccountingSettings {
-    currency: IAccountingCurrencySettings<any>; // IAccountingCurrencySettings<string> or IAccountingCurrencySettings<IAccountingCurrencyFormat>
-    number: IAccountingNumberSettings;
-}
-
-interface IAccountingStatic {
-    // format any number into currency
-    formatMoney(number: number, symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string;
-    formatMoney(number: number, options: IAccountingCurrencySettings<string>): string;
-    formatMoney(number: number, options: IAccountingCurrencySettings<IAccountingCurrencyFormat>): string;
-
-    formatMoney(numbers: number[], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string[];
-    formatMoney(numbers: number[], options: IAccountingCurrencySettings<string>): string[];
-    formatMoney(numbers: number[], options: IAccountingCurrencySettings<IAccountingCurrencyFormat>): string[];
-
-    // generic case (any array of numbers)
-    formatMoney(numbers: any[], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): any[];
-    formatMoney(numbers: any[], options: IAccountingCurrencySettings<string>): any[];
-    formatMoney(numbers: any[], options: IAccountingCurrencySettings<IAccountingCurrencyFormat>): any[];
-
-    // format a list of values for column-display
-    formatColumn(numbers: number[], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string[];
-    formatColumn(numbers: number[], options: IAccountingCurrencySettings<string>): string[];
-    formatColumn(numbers: number[], options: IAccountingCurrencySettings<IAccountingCurrencyFormat>): string[];
-
-    formatColumn(numbers: number[][], symbol?: string, precision?: number, thousand?: string, decimal?: string, format?: string): string[][];
-    formatColumn(numbers: number[][], options: IAccountingCurrencySettings<string>): string[][];
-    formatColumn(numbers: number[][], options: IAccountingCurrencySettings<IAccountingCurrencyFormat>): string[][];
-
-    // format a number with custom precision and localisation
-    formatNumber(number: number, precision?: number, thousand?: string, decimal?: string): string;
-    formatNumber(number: number, options: IAccountingNumberSettings): string;
-
-    formatNumber(number: number[], precision?: number, thousand?: string, decimal?: string): string[];
-    formatNumber(number: number[], options: IAccountingNumberSettings): string[];
-
-    formatNumber(number: any[], precision?: number, thousand?: string, decimal?: string): any[];
-    formatNumber(number: any[], options: IAccountingNumberSettings): any[];
-
-    // better rounding for floating point numbers
-    toFixed(number: number, precision?: number): string;
-
-    // get a value from any formatted number/currency string
-    unformat(string: string, decimal?: string): number;
-
-    // settings object that controls default parameters for library methods
-    settings: IAccountingSettings;
-}
-
-declare var accounting: IAccountingStatic;
-
-declare module "accounting" {
-    export = accounting;
-}
+declare var accounting: accounting.IAccountingStatic;
+export = accounting;
+export as namespace accounting;

accounting/tslint.json

@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

adm-zip/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for adm-zip v0.4.4
+// Type definitions for adm-zip v0.4.4
 // Project: https://github.com/cthackers/adm-zip
 // Definitions by: John Vilk <https://github.com/jvilk>, Abner Oliveira <https://github.com/abner>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

ajv/index.d.ts

@@ -66,18 +66,20 @@ declare namespace Ajv {
         unicode?: boolean;
         format?: string;
         formats?: any;
+        unknownFormats?: true | string[] | "ignore";
         schemas?: any;
-        missingRefs?: boolean;
+        missingRefs?: true | "ignore" | "fail";
+        extendRefs?: true | "ignore" | "fail";
         loadSchema?(uri: string, callback: (error: Error, body: any) => void): void;
-        removeAdditional?: boolean;
-        useDefaults?: boolean;
-        coerceTypes?: boolean;
+        removeAdditional?: boolean | "all" | "failing";
+        useDefaults?: boolean | "shared";
+        coerceTypes?: boolean | "array";
         async?: any;
         transpile?: string;
         meta?: boolean;
-        validateSchema?: boolean;
+        validateSchema?: boolean | "log";
         addUsedSchema?: boolean;
-        inlineRefs?: boolean;
+        inlineRefs?: boolean | number;
         passContext?: boolean;
         loopRequired?: number;
         ownProperties?: boolean;

alertify/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for alertify 0.3.11
+// Type definitions for alertify 0.3.11
 // Project: http://fabien-d.github.io/alertify.js/
 // Definitions by: John Jeffery <http://github.com/jjeffery>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

algoliasearch/algoliasearch-tests.ts

@@ -1,5 +1,6 @@
-
 import algoliasearch = require('algoliasearch');
+import { ClientOptions, SynonymOption, AlgoliaUserKeyOptions, SearchSynonymOptions,
+    AlgoliaSecuredApiOptions, AlgoliaIndexSettings, AlgoliaQueryParameters, AlgoliaIndex } from "algoliasearch";
 
 var _clientOptions: ClientOptions = {
     timeout : 12,

algoliasearch/tsconfig.json

@@ -14,6 +14,6 @@
     },
     "files": [
         "index.d.ts",
-        "algoliasearch-client-js-tests.ts"
+        "algoliasearch-tests.ts"
     ]
 }

amcharts/index.d.ts

@@ -24,6 +24,9 @@ declare namespace AmCharts {
     /** Set it to true if you want UTC time to be used instead of local time. */
     var useUTC: boolean;
 
+    /** Object with themes */
+    var themes: any;
+
     /** Clears all the charts on page, removes listeners and intervals. */
     function clear(): void;
 

amplify-deferred/amplify-deferred-tests.ts

@@ -1,265 +1,5 @@
-
-/// <reference types="jquery" />
-
-// Copied examples directly from AmplifyJs site
-
-// Subscribe and publish with no data
-
-amplify.subscribe("nodataexample", function () {
-    alert("nodataexample topic published!");
-});
-
-// Subscribe and publish with data
-
-amplify.publish("nodataexample");
-
-amplify.subscribe("dataexample", function (data) {
-    alert(data.foo); // bar
-});
-
-
-amplify.publish("dataexample", { foo: "bar" });
-
-amplify.subscribe("dataexample2", function (param1, param2) {
-    alert(param1 + param2); // barbaz
-});
-
-//...
-
-amplify.publish("dataexample2", "bar", "baz");
-
-// Subscribe and publish with context and data
-
-amplify.subscribe("datacontextexample", $("p:first"), function (data) {
-    this.text(data.exampleText); // first p element would have "foo bar baz" as text
-});
-
-amplify.publish("datacontextexample", { exampleText: "foo bar baz" });
-
-// Subscribe to a topic with high priority
-
-amplify.subscribe("priorityexample", function (data) {
-    alert(data.foo);
-});
-
-amplify.subscribe("priorityexample", function (data) {
-    if (data.foo === "oops") {
-        return false;
-    }
-}, 1);
-
-
-// Store data with amplify storage picking the default storage technology:
-
-amplify.publish("priorityexample", { foo: "bar" });
-amplify.publish("priorityexample", { foo: "oops" });
-
-amplify.store("storeExample1", { foo: "bar" });
-amplify.store("storeExample2", "baz");
-// retrieve the data later via the key
-var myStoredValue = amplify.store("storeExample1"),
-    myStoredValue2 = amplify.store("storeExample2"),
-    myStoredValues = amplify.store();
-myStoredValue.foo; // bar
-myStoredValue2; // baz
-myStoredValues.storeExample1.foo; // bar
-myStoredValues.storeExample2; // baz
-
-// Store data explicitly with session storage
-
-amplify.store.sessionStorage("explicitExample", { foo2: "baz" });
-// retrieve the data later via the key
-var myStoredValue2 = amplify.store.sessionStorage("explicitExample");
-myStoredValue2.foo2; // baz
-
-
-// REQUEST
-
-// Set up and use a request utilizing Ajax
-
-
-amplify.request.define("ajaxExample1", "ajax", {
-    url: "/myApiUrl",
-    dataType: "json",
-    type: "GET"
-});
-
-// later in code
-amplify.request("ajaxExample1", function (data) {
-    data.foo; // bar
-});
-
-// Set up and use a request utilizing Ajax and Caching
-
-amplify.request.define("ajaxExample2", "ajax", {
-    url: "/myApiUrl",
-    dataType: "json",
-    type: "GET",
-    cache: "persist"
-});
-
-// later in code
-amplify.request("ajaxExample2", function (data) {
-    data.foo; // bar
-});
-
-// a second call will result in pulling from the cache
-amplify.request("ajaxExample2", function (data) {
-    data.baz; // qux
-})
-
-// Set up and use a RESTful request utilizing Ajax
-
-amplify.request.define("ajaxRESTFulExample", "ajax", {
-    url: "/myRestFulApi/{type}/{id}",
-    type: "GET"
-})
-
-// later in code
-amplify.request("ajaxRESTFulExample",
-    {
-        type: "foo",
-        id: "bar"
-    },
-    function (data) {
-        // /myRESTFulApi/foo/bar was the URL used
-        data.foo; // bar
-    }
-    );
-
-// POST data with Ajax
-
-amplify.request.define("ajaxPostExample", "ajax", {
-    url: "/myRestFulApi",
-    type: "POST"
-})
-
-// later in code
-amplify.request("ajaxPostExample",
-    {
-        type: "foo",
-        id: "bar"
-    },
-    function (data) {
-        data.foo; // bar
-    }
-    );
-// Using data maps
-
-//  When searching Twitter, the key for the search phrase is q.If we want a more descriptive name, such as term, we can use a data map:
-
-amplify.request.define("twitter-search", "ajax", {
-    url: "http://search.twitter.com/search.json",
-    dataType: "jsonp",
-    dataMap: {
-        term: "q"
-    }
-});
-
-amplify.request("twitter-search", { term: "amplifyjs" });
-
-// Similarly, we can create a request that searches for mentions, by accepting a username:
-
-amplify.request.define("twitter-mentions", "ajax", {
-    url: "http://search.twitter.com/search.json",
-    dataType: "jsonp",
-    dataMap: function (data) {
-        return {
-            q: "@" + data.user
-        };
-    }
-});
-
-amplify.request("twitter-mentions", { user: "amplifyjs" });
-
-// Setting up and using decoders
-
-//Example:
-
-var appEnvelopeDecoder: amplifyDecoder = function (data, status, xhr, success, error) {
-    if (data.status === "success") {
-        success(data.data);
-    } else if (data.status === "fail" || data.status === "error") {
-        error(data.message, data.status);
-    } else {
-        error(data.message, "fatal");
-    }
-};
-
-//a new decoder can be added to the amplifyDecoders interface
-interface amplifyDecoders {
-    appEnvelope: amplifyDecoder;
-}
-
-amplify.request.decoders.appEnvelope = appEnvelopeDecoder;
-
-//but you can also just add it via an index
-amplify.request.decoders['appEnvelopeStr'] = appEnvelopeDecoder;
-
-
-amplify.request.define("decoderExample", "ajax", {
-    url: "/myAjaxUrl",
-    type: "POST",
-    decoder: "appEnvelope"
-});
-
-amplify.request({
-    resourceId: "decoderExample",
-    success: function (data) {
-        data.foo; // bar
-    },
-    error: function (message, level) {
-        alert("always handle errors with alerts.");
-    }
-});
-
-// POST with caching and single - use decoder
-
-// Example:
-
-amplify.request.define("decoderSingleExample", "ajax", {
-    url: "/myAjaxUrl",
-    type: "POST",
-    decoder: function (data, status, xhr, success, error) {
-        if (data.status === "success") {
-            success(data.data);
-        } else if (data.status === "fail" || data.status === "error") {
-            error(data.message, data.status);
-        } else {
-            error(data.message, "fatal");
-        }
-    }
-});
-
-amplify.request({
-    resourceId: "decoderSingleExample",
-    success: function (data) {
-        data.foo; // bar
-    },
-    error: function (message, level) {
-        alert("always handle errors with alerts.");
-    }
-});
-// Handling Status
-// Status in Success and Error Callbacks
-
-// amplify.request comes with built in support for status.The status parameter appears in the default success or error callbacks when using an ajax definition.
-
-amplify.request.define("statusExample1", "ajax", {
-    //...
-});
-
-amplify.request({
-    resourceId: "statusExample1",
-    success: function (data, status) {
-    },
-    error: function (data, status) {
-    }
-});
-
 amplify.request({
     resourceId: "statusExample1"
 }).done(function (data, status) {
 }).fail(function (data, status) {
 }).always(function (data, status) { });
-

amplify-deferred/index.d.ts

@@ -5,178 +5,26 @@
 
 /// <reference types="jquery" />
 
-interface amplifyRequestSettings {
-    resourceId: string;
-    data?: any;
-    success?: (...args: any[]) => void;
-    error?: (...args: any[]) => void;
+import * as amplify from "amplify";
+
+declare module "amplify" {
+    interface Request {
+        /***
+        * Request a resource.
+        * resourceId: Identifier string for the resource.
+        * data: A set of key/value pairs of data to be sent to the resource.
+        * callback: A function to invoke if the resource is retrieved successfully.
+        */
+        (resourceId: string, hash?: any, callback?: Function): JQueryPromise<any>;
+
+        /***
+        * Request a resource.
+        * settings: A set of key/value pairs of settings for the request.
+        *   resourceId: Identifier string for the resource.
+        *   data (optional): Data associated with the request.
+        *   success (optional): Function to invoke on success.
+        *   error (optional): Function to invoke on error.
+        */
+        (settings: RequestSettings): JQueryPromise<any>;
+    }
 }
-
-interface amplifyDecoder {
-    (
-        data?: any,
-        status?: string,
-        xhr?: JQueryXHR,
-        success?: (...args: any[]) => void,
-        error?: (...args: any[]) => void
-        ): void
-}
-
-interface amplifyDecoders {
-    [decoderName: string]: amplifyDecoder;
-    jsSend: amplifyDecoder;
-}
-
-interface amplifyAjaxSettings extends JQueryAjaxSettings {
-    cache?: any;
-    dataMap?: {} | ((data: any) => {});
-    decoder?: any /* string or amplifyDecoder */;
-}
-
-interface amplifyRequest {
-
-    /***
-    * Request a resource.
-    * resourceId: Identifier string for the resource.
-    * data: A set of key/value pairs of data to be sent to the resource.
-    * callback: A function to invoke if the resource is retrieved successfully.
-    */
-    (resourceId: string, hash?: any, callback?: Function): JQueryPromise<any>;
-
-    /***
-    * Request a resource.
-    * settings: A set of key/value pairs of settings for the request.
-    *   resourceId: Identifier string for the resource.
-    *   data (optional): Data associated with the request.
-    *   success (optional): Function to invoke on success.
-    *   error (optional): Function to invoke on error.
-    */
-    (settings: amplifyRequestSettings): JQueryPromise<any>;
-
-    /***
-    * Define a resource.
-    * resourceId: Identifier string for the resource.
-    * requestType: The type of data retrieval method from the server. See the request types sections for more information.
-    * settings: A set of key/value pairs that relate to the server communication technology. The following settings are available:
-    *   Any settings found in jQuery.ajax().
-    *   cache: See the cache section for more details.
-    *   decoder: See the decoder section for more details.
-    */
-    define(resourceId: string, requestType: string, settings?: amplifyAjaxSettings): void;
-
-    /***
-    * Define a custom request.
-    * resourceId: Identifier string for the resource.
-    * resource: Function to handle requests. Receives a hash with the following properties:
-    *   resourceId: Identifier string for the resource.
-    *   data: Data provided by the user.
-    *   success: Callback to invoke on success.
-    *   error: Callback to invoke on error.
-    */
-    define(resourceId: string, resource: (settings: amplifyRequestSettings) => void): void;
-
-    decoders: amplifyDecoders;
-    cache: any;
-}
-
-interface amplifySubscribe {
-    /***
-    * Subscribe to a message.
-    * topic: Name of the message to subscribe to.
-    * callback: Function to invoke when the message is published.
-    */
-    (topic: string, callback: Function): void;
-    /***
-    * Subscribe to a message.
-    * topic: Name of the message to subscribe to.
-    * context: What this will be when the callback is invoked.
-    * callback: Function to invoke when the message is published.
-    * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
-    */
-    (topic: string, context: any, callback: Function, priority?: number): void;
-    /***
-    * Subscribe to a message.
-    * topic: Name of the message to subscribe to.
-    * callback: Function to invoke when the message is published.
-    * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
-    */
-    (topic: string, callback: Function, priority?: number): void;
-}
-interface amplifyStorageTypeStore {
-    /***
-    * Stores a value for a given key using the default storage type.
-    * 
-    * key: Identifier for the value being stored.
-    * value: The value to store. The value can be anything that can be serialized as JSON.
-    * [options]: A set of key/value pairs that relate to settings for storing the value.
-    */
-    (key: string, value: any, options?: any): void;
-
-    /***
-    * Gets a stored value based on the key.
-    */
-    (key: string): any;
-
-    /***
-    * Gets a hash of all stored values.
-    */
-    (): any;
-}
-
-interface amplifyStore extends amplifyStorageTypeStore {
-
-    /*** 
-    * IE 8+, Firefox 3.5+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
-    */
-    localStorage: amplifyStorageTypeStore;
-
-    /*** 
-    * IE 8+, Firefox 2+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
-    */
-    sessionStorage: amplifyStorageTypeStore;
-
-    /***
-    * Firefox 2+
-    */
-    globalStorage: amplifyStorageTypeStore;
-    
-    /***
-    * IE 5 - 7
-    */
-    userData: amplifyStorageTypeStore;
-
-    /***
-    * An in-memory store is provided as a fallback if none of the other storage types are available.
-    */
-    memory: amplifyStorageTypeStore;
-
-
-}
-
-interface amplifyStatic {
-
-    subscribe: amplifySubscribe;
-
-    /***
-    * Remove a subscription.
-    * topic: The topic being unsubscribed from.
-    * callback: The callback that was originally subscribed.
-    */
-    unsubscribe(topic: string, callback: Function): void;
-
-    /***
-    * Publish a message.
-    * topic: The name of the message to publish.
-    * Any additional parameters will be passed to the subscriptions.
-    * amplify.publish returns a boolean indicating whether any subscriptions returned false. The return value is true if none of the subscriptions returned false, and false otherwise. Note that only one subscription can return false because doing so will prevent additional subscriptions from being invoked.
-    */
-    publish(topic: string, ...args: any[]): boolean;
-
-    store: amplifyStore;
-
-    request: amplifyRequest;
-
-}
-
-declare var amplify: amplifyStatic;
-

amplify-deferred/tslint.json

@@ -0,0 +1,6 @@
+{
+    "extends": "../tslint.json",
+    "rules": {
+        "forbidden-types": false
+    }
+}

amplify/amplifyjs-tests.ts

@@ -1,6 +1,8 @@
 
 /// <reference types="jquery" />
 
+import amplify = require("amplify");
+
 // Copied examples directly from AmplifyJs site
 
 // Subscribe and publish with no data
@@ -176,7 +178,7 @@ amplify.request("twitter-mentions", { user: "amplifyjs" });
 
 //Example:
 
-var appEnvelopeDecoder: amplifyDecoder = function (data, status, xhr, success, error) {
+var appEnvelopeDecoder: amplify.Decoder = function (data, status, xhr, success, error) {
     if (data.status === "success") {
         success(data.data);
     } else if (data.status === "fail" || data.status === "error") {
@@ -187,8 +189,10 @@ var appEnvelopeDecoder: amplifyDecoder = function (data, status, xhr, success, e
 };
 
 //a new decoder can be added to the amplifyDecoders interface
-interface amplifyDecoders {
-    appEnvelope: amplifyDecoder;
+declare module "amplify" {
+    interface Decoders {
+        appEnvelope: amplify.Decoder;
+    }
 }
 
 amplify.request.decoders.appEnvelope = appEnvelopeDecoder;

amplify/index.d.ts

@@ -5,178 +5,173 @@
 
 /// <reference types="jquery" />
 
-interface amplifyRequestSettings {
-    resourceId: string;
-    data?: any;
-    success?: (...args: any[]) => void;
-    error?: (...args: any[]) => void;
+declare namespace amplify {
+    interface RequestSettings {
+        resourceId: string;
+        data?: any;
+        success?: (...args: any[]) => void;
+        error?: (...args: any[]) => void;
+    }
+
+    type Decoder =
+        (
+            data?: any,
+            status?: string,
+            xhr?: JQueryXHR,
+            success?: (...args: any[]) => void,
+            error?: (...args: any[]) => void
+        ) => void;
+
+    interface Decoders {
+        [decoderName: string]: Decoder;
+        jsSend: Decoder;
+    }
+
+    interface AjaxSettings extends JQueryAjaxSettings  {
+        cache?: any;
+        dataMap?: {} | ((data: any) => {});
+        decoder?: any /* string or amplifyDecoder */;
+    }
+
+    interface Request {
+
+        /***
+        * Request a resource.
+        * resourceId: Identifier string for the resource.
+        * data: A set of key/value pairs of data to be sent to the resource.
+        * callback: A function to invoke if the resource is retrieved successfully.
+        */
+        (resourceId: string, hash?: any, callback?: Function): void;
+
+        /***
+        * Request a resource.
+        * settings: A set of key/value pairs of settings for the request.
+        *   resourceId: Identifier string for the resource.
+        *   data (optional): Data associated with the request.
+        *   success (optional): Function to invoke on success.
+        *   error (optional): Function to invoke on error.
+        */
+        (settings: RequestSettings): any;
+
+        /***
+        * Define a resource.
+        * resourceId: Identifier string for the resource.
+        * requestType: The type of data retrieval method from the server. See the request types sections for more information.
+        * settings: A set of key/value pairs that relate to the server communication technology. The following settings are available:
+        *   Any settings found in jQuery.ajax().
+        *   cache: See the cache section for more details.
+        *   decoder: See the decoder section for more details.
+        */
+        define(resourceId: string, requestType: string, settings?: AjaxSettings): void;
+
+        /***
+        * Define a custom request.
+        * resourceId: Identifier string for the resource.
+        * resource: Function to handle requests. Receives a hash with the following properties:
+        *   resourceId: Identifier string for the resource.
+        *   data: Data provided by the user.
+        *   success: Callback to invoke on success.
+        *   error: Callback to invoke on error.
+        */
+        define(resourceId: string, resource: (settings: RequestSettings) => void): void;
+
+        decoders: Decoders;
+        cache: any;
+    }
+
+    interface Subscribe {
+        /***
+        * Subscribe to a message.
+        * topic: Name of the message to subscribe to.
+        * callback: Function to invoke when the message is published.
+        * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
+        */
+        (topic: string, callback: Function, priority?: number): void;
+        /***
+        * Subscribe to a message.
+        * topic: Name of the message to subscribe to.
+        * context: What this will be when the callback is invoked.
+        * callback: Function to invoke when the message is published.
+        * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
+        */
+        (topic: string, context: any, callback: Function, priority?: number): void;
+    }
+    interface StorageTypeStore {
+        /***
+        * Stores a value for a given key using the default storage type.
+        *
+        * key: Identifier for the value being stored.
+        * value: The value to store. The value can be anything that can be serialized as JSON.
+        * [options]: A set of key/value pairs that relate to settings for storing the value.
+        */
+        (key: string, value: any, options?: any): void;
+
+        /***
+        * Gets a stored value based on the key.
+        */
+        (key: string): any;
+
+        /***
+        * Gets a hash of all stored values.
+        */
+        (): any;
+    }
+
+    interface Store extends StorageTypeStore {
+
+        /***
+        * IE 8+, Firefox 3.5+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
+        */
+        localStorage: StorageTypeStore;
+
+        /***
+        * IE 8+, Firefox 2+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
+        */
+        sessionStorage: StorageTypeStore;
+
+        /***
+        * Firefox 2+
+        */
+        globalStorage: StorageTypeStore;
+
+        /***
+        * IE 5 - 7
+        */
+        userData: StorageTypeStore;
+
+        /***
+        * An in-memory store is provided as a fallback if none of the other storage types are available.
+        */
+        memory: StorageTypeStore;
+
+
+    }
+
+    interface Static {
+
+        subscribe: Subscribe;
+
+        /***
+        * Remove a subscription.
+        * topic: The topic being unsubscribed from.
+        * callback: The callback that was originally subscribed.
+        */
+        unsubscribe(topic: string, callback: Function): void;
+
+        /***
+        * Publish a message.
+        * topic: The name of the message to publish.
+        * Any additional parameters will be passed to the subscriptions.
+        * amplify.publish returns a boolean indicating whether any subscriptions returned false. The return value is true if none of the subscriptions returned false, and false otherwise. Note that only one subscription can return false because doing so will prevent additional subscriptions from being invoked.
+        */
+        publish(topic: string, ...args: any[]): boolean;
+
+        store: Store;
+
+        request: Request;
+    }
 }
 
-interface amplifyDecoder {
-    (   
-        data?: any, 
-        status?: string, 
-        xhr?: JQueryXHR, 
-        success?: (...args: any[]) => void,
-        error?: (...args: any[]) => void
-    ): void
-}
-
-interface amplifyDecoders {
-    [decoderName: string]: amplifyDecoder;
-    jsSend: amplifyDecoder;
-}
-
-interface amplifyAjaxSettings extends JQueryAjaxSettings  {
-    cache?: any;
-    dataMap?: {} | ((data: any) => {});
-    decoder?: any /* string or amplifyDecoder */;
-}
-
-interface amplifyRequest {
-
-    /***
-    * Request a resource.
-    * resourceId: Identifier string for the resource.
-    * data: A set of key/value pairs of data to be sent to the resource.
-    * callback: A function to invoke if the resource is retrieved successfully.
-    */
-    (resourceId: string, hash?: any, callback?: Function): void;
-
-    /***
-    * Request a resource.
-    * settings: A set of key/value pairs of settings for the request.
-    *   resourceId: Identifier string for the resource.
-    *   data (optional): Data associated with the request.
-    *   success (optional): Function to invoke on success.
-    *   error (optional): Function to invoke on error.
-    */
-    (settings: amplifyRequestSettings): any;
-
-    /***
-    * Define a resource.
-    * resourceId: Identifier string for the resource.
-    * requestType: The type of data retrieval method from the server. See the request types sections for more information.
-    * settings: A set of key/value pairs that relate to the server communication technology. The following settings are available:
-    *   Any settings found in jQuery.ajax().
-    *   cache: See the cache section for more details.
-    *   decoder: See the decoder section for more details.
-    */
-    define(resourceId: string, requestType: string, settings?: amplifyAjaxSettings): void;
-
-    /***
-    * Define a custom request.
-    * resourceId: Identifier string for the resource.
-    * resource: Function to handle requests. Receives a hash with the following properties:
-    *   resourceId: Identifier string for the resource.
-    *   data: Data provided by the user.
-    *   success: Callback to invoke on success.
-    *   error: Callback to invoke on error.
-    */
-    define(resourceId: string, resource: (settings: amplifyRequestSettings) => void): void;
-    
-    decoders: amplifyDecoders;
-    cache: any;
-}
-
-interface amplifySubscribe {
-    /***
-    * Subscribe to a message.
-    * topic: Name of the message to subscribe to.
-    * callback: Function to invoke when the message is published.
-    */
-    (topic: string, callback: Function): void;
-    /***
-    * Subscribe to a message.
-    * topic: Name of the message to subscribe to.
-    * context: What this will be when the callback is invoked.
-    * callback: Function to invoke when the message is published.
-    * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
-    */
-    (topic: string, context: any, callback: Function, priority?: number): void;
-    /***
-    * Subscribe to a message.
-    * topic: Name of the message to subscribe to.
-    * callback: Function to invoke when the message is published.
-    * [priority]: Priority relative to other subscriptions for the same message. Lower values have higher priority. Default is 10.
-    */
-    (topic: string, callback: Function, priority?: number): void;
-}
-interface amplifyStorageTypeStore {
-    /***
-    * Stores a value for a given key using the default storage type.
-    * 
-    * key: Identifier for the value being stored.
-    * value: The value to store. The value can be anything that can be serialized as JSON.
-    * [options]: A set of key/value pairs that relate to settings for storing the value.
-    */
-    (key: string, value: any, options?: any): void;
-
-    /***
-    * Gets a stored value based on the key.
-    */
-    (key: string): any;
-
-    /***
-    * Gets a hash of all stored values.
-    */
-    (): any;
-}
-
-interface amplifyStore extends amplifyStorageTypeStore{
-
-    /*** 
-    * IE 8+, Firefox 3.5+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
-    */
-    localStorage: amplifyStorageTypeStore;
-
-    /*** 
-    * IE 8+, Firefox 2+, Safari 4+, Chrome, Opera 10.5+, iPhone 2+, Android 2+
-    */
-    sessionStorage: amplifyStorageTypeStore;
-
-    /***
-    * Firefox 2+
-    */
-    globalStorage: amplifyStorageTypeStore;
-    
-    /***
-    * IE 5 - 7
-    */
-    userData: amplifyStorageTypeStore;
-
-    /***
-    * An in-memory store is provided as a fallback if none of the other storage types are available.
-    */
-    memory: amplifyStorageTypeStore;
-    
-    
-}
-
-interface amplifyStatic {
-
-    subscribe: amplifySubscribe;
-
-    /***
-    * Remove a subscription.
-    * topic: The topic being unsubscribed from.
-    * callback: The callback that was originally subscribed.
-    */
-    unsubscribe(topic: string, callback: Function): void;
-
-    /***
-    * Publish a message.
-    * topic: The name of the message to publish.
-    * Any additional parameters will be passed to the subscriptions.
-    * amplify.publish returns a boolean indicating whether any subscriptions returned false. The return value is true if none of the subscriptions returned false, and false otherwise. Note that only one subscription can return false because doing so will prevent additional subscriptions from being invoked.
-    */
-    publish(topic: string, ...args: any[]): boolean;
-
-    store: amplifyStore;
-
-    request: amplifyRequest;
-
-}
-
-declare var amplify: amplifyStatic;
-declare module "amplify" { export =amplify; }
+declare var amplify: amplify.Static;
+export = amplify;
+export as namespace amplify;

amplify/tslint.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../tslint.json",
+    "rules": {
+        "forbidden-types": false,
+        "unified-signatures": false
+    }
+}

angular-bootstrap-calendar/index.d.ts

@@ -7,7 +7,35 @@ import * as moment from 'moment';
 import * as angular from 'angular';
 
 declare module 'angular' {
-    export namespace bootstrap.calendar {
+	    export namespace bootstrap.calendar {
+	    interface IEventAction {
+	        /**
+	         * The label of the action
+	         */
+	        label: string;
+	        /**
+	         * CSS class to be added to the action element
+	         */
+	        cssClass?: string;
+	        /**
+	         * The action that occurs when it's clicked
+	         * @param args - the IEvent whose action was clicked
+	         */
+	        onClick: (args: any) => void;
+	    }
+
+	    interface IEventColor {
+	        /**
+	         * The primary color of the event, should be darker than secondary
+	         */
+	        primary: string;
+
+	        /**
+	         * The secondary color of the event, should be lighter than primary
+	         */
+	        secondary: string;
+	    }
+
         interface IEvent {
             /**
              * The title of the event
@@ -16,7 +44,7 @@ declare module 'angular' {
             /**
              * The type of the event (determines its color). Can be important, warning, info, inverse, success or special
              */
-            type: string;
+            type?: string;
             /**
              * A javascript date object for when the event starts
              */
@@ -25,6 +53,14 @@ declare module 'angular' {
              * Optional - a javascript date object for when the event ends
              */
             endsAt?: Date;
+	        /**
+	         * Color of the Event
+	         */
+	        color?: IEventColor;
+	        /**
+	         * Actions of the Event
+	         */
+	        actions?: Array<IEventAction>;
             /**
              * If edit-event-html is set and this field is explicitly set to false then dont make it editable.
              */
@@ -53,6 +89,10 @@ declare module 'angular' {
              * A CSS class (or more, just separate with spaces) that will be added to the event when it is displayed on each view. Useful for marking an event as selected / active etc
              */
             cssClass?: string;
+	        /**
+	         * If set the event will display as all-day event
+	         */
+	        allDay?: boolean;
         }
 
         interface ICalendarConfig {
@@ -134,7 +174,7 @@ declare module 'angular' {
             }
 
             interface IOnViewChangeClick {
-                (calendarDate: Date, calendarNextView: string): void;
+                (calendarDate: Date, calendarNextView: string): boolean;
             }
         }
     }

angular-breadcrumb/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for angular-breadcrumb 0.4.1
+// Type definitions for angular-breadcrumb 0.4.1
 // Project: https://github.com/ncuillery/angular-breadcrumb
 // Definitions by: Marc Talary <https://github.com/marctalary>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -76,4 +76,4 @@ declare namespace ncy {
         **/
         getLastStep(): angular.ui.IState;
     }
-}
+}

angular-file-saver/angular-file-saver-tests.ts

@@ -0,0 +1,10 @@
+class ExampleCtrl {
+    constructor(FileSaver: angular.FileSaver) {
+        var data = new Blob(["Hey ho lets go!"], { type: "text/plain;charset=utf-8" });
+        FileSaver.saveAs(data, "text.txt");
+    }
+}
+
+angular
+    .module("fileSaverExample", ["ngFileSaver"])
+    .controller("ExampleCtrl",  ExampleCtrl);

angular-file-saver/index.d.ts

@@ -0,0 +1,21 @@
+// Type definitions for angular-file-saver 1.2.0
+// Project: https://github.com/alferov/angular-file-saver
+// Definitions by: Donald Nairn <https://github.com/deenairn/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="angular" />
+
+declare namespace angular {
+    /**
+     * A core Angular factory proving FileSaver functionality.
+     */
+    interface FileSaver {
+        /**
+         * Immediately starts saving a file
+         * @param data: a Blob instance;
+         * @param filename: a String custom filename (an extension is optional);
+         * @param disableAutoBOM : (optional) Boolean Disable automatically provided Unicode text encoding hints;
+         */
+        saveAs(blob: Blob, fileName: string, disableBOM?: boolean): void;
+    }
+}

angular-file-saver/tsconfig.json

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

angular-idle/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for ng-idle v1.1.1
+// Type definitions for ng-idle v1.1.1
 // Project: http://hackedbychinese.github.io/ng-idle/
 // Definitions by: mthamil <https://github.com/mthamil>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

angular-jwt/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for angular-jwt 0.0.8
+// Type definitions for angular-jwt 0.0.8
 // Project: https://github.com/auth0/angular-jwt
 // Definitions by: Reto Rezzonico <https://github.com/rerezz>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

angular-material/index.d.ts

@@ -76,7 +76,7 @@ declare module 'angular' {
         }
 
         interface IColorService {
-            applyThemeColors(element: Element|JQuery, colorExpression: IColorExpression): void;
+            applyThemeColors(element: Element | JQuery, colorExpression: IColorExpression): void;
             getThemeColor(expression: string): string;
             hasTheme(): boolean;
         }
@@ -158,7 +158,7 @@ declare module 'angular' {
             hideDelay(delay: number): T;
             position(position: string): T;
             parent(parent?: string | Element | JQuery): T; // default: root node
-        toastClass(toastClass: string): T;
+            toastClass(toastClass: string): T;
         }
 
         interface ISimpleToastPreset extends IToastPreset<ISimpleToastPreset> {
@@ -225,7 +225,7 @@ declare module 'angular' {
             hues: IThemeHues;
         }
 
-        interface IBrowserColors{
+        interface IBrowserColors {
             theme: string;
             palette: string;
             hue: string;
@@ -264,6 +264,7 @@ declare module 'angular' {
             definePalette(name: string, palette: IPalette): IThemingProvider;
             enableBrowserColor(browserColors: IBrowserColors): Function;
             extendPalette(name: string, palette: IPalette): IPalette;
+            registerStyles(styles: String): void;
             setDefaultTheme(theme: string): void;
             setNonce(nonce: string): void;
             theme(name: string, inheritFrom?: string): ITheme;
@@ -414,7 +415,7 @@ declare module 'angular' {
                 ESCAPE: string,
             };
             absPosition: {
-                TOP:  string,
+                TOP: string,
                 RIGHT: string,
                 BOTTOM: string,
                 LEFT: string,

angular-media-queries/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Angular matchMedia 0.6.0 (angular.matchMedia module)
+// Type definitions for Angular matchMedia 0.6.0 (angular.matchMedia module)
 // Project: https://github.com/jacopotarantino/angular-match-media
 // Definitions by: Joao Monteiro <https://github.com/jpmnteiro>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

angular-mocks/angular-mocks-tests.ts

@@ -106,6 +106,7 @@ $componentController<{}, { test: boolean }>('Test controller', { $scope: <ng.ISc
 $componentController<{}, { test?: boolean }>('Test controller', { $scope: <ng.IScope>{} }, {});
 $componentController<{}, {}>('Test controller', { $scope: <ng.IScope>{} }, {}, 'identity');
 $componentController<{ cb: () => void }, {}>('Test controller', { $scope: <ng.IScope>{} });
+$componentController<{}, { test: {name: string} }>('Test controller', { test: {name: 'Test Local'} });
 
 ///////////////////////////////////////
 // IHttpBackendService
@@ -451,11 +452,11 @@ requestHandler.passThrough().passThrough();
 requestHandler.respond((method, url, data, headers) => [404, 'data', { header: 'value' }, 'responseText']);
 requestHandler.respond((method, url, data, headers) => [404, 'data', { header: 'value' }, 'responseText']).respond({});
 requestHandler.respond((method, url, data, headers) => { return [404, { key: 'value' }, { header: 'value' }, 'responseText']; });
-requestHandler.respond((method, url, data, headers, params) => { 
+requestHandler.respond((method, url, data, headers, params) => {
     if(params.id === 1) {
         return [200, { key: 'value'}, { header: 'value'}, 'responseText'];
     } else {
-        return [404, { key: 'value' }, { header: 'value' }, 'responseText']; 
+        return [404, { key: 'value' }, { header: 'value' }, 'responseText'];
     }
 });
 requestHandler.respond('data');

angular-mocks/index.d.ts

@@ -117,10 +117,13 @@ declare module 'angular' {
   ///////////////////////////////////////////////////////////////////////////
   interface IHttpBackendService {
     /**
-      * Flushes all pending requests using the trained responses.
-      * @param count Number of responses to flush (in the order they arrived). If undefined, all pending requests will be flushed.
+      * Flushes pending requests using the trained responses. Requests are flushed in the order they were made, but it is also possible to skip one or more requests (for example to have them flushed later). This is useful for simulating scenarios where responses arrive from the server in any order.
+      *
+      * If there are no pending requests to flush when the method is called, an exception is thrown (as this is typically a sign of programming error).
+      * @param count Number of responses to flush. If undefined/null, all pending requests (starting after `skip`) will be flushed.
+      * @param skip Number of pending requests to skip. For example, a value of 5 would skip the first 5 pending requests and start flushing from the 6th onwards. _(default: 0)_
       */
-    flush(count?: number): void;
+    flush(count?: number, skip?: number): void;
 
     /**
       * Resets all request expectations, but preserves all backend definitions.
@@ -301,6 +304,25 @@ declare module 'angular' {
     whenPUT(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object | ((object: Object) => boolean), keys?: Object[]): mock.IRequestHandler;
   }
 
+  ///////////////////////////////////////////////////////////////////////////
+  // AnimateService
+  // see https://docs.angularjs.org/api/ngMock/service/$animate
+  ///////////////////////////////////////////////////////////////////////////
+  module animate {
+    interface IAnimateService {
+
+      /**
+       * This method will close all pending animations (both Javascript and CSS) and it will also flush any remaining animation frames and/or callbacks.
+       */
+      closeAndFlush(): void;
+
+      /**
+       * This method is used to flush the pending callbacks and animation frames to either start an animation or conclude an animation. Note that this will not actually close an actively running animation (see `closeAndFlush()` for that).
+       */
+      flush(): void;
+    }
+  }
+
   export module mock {
     // returned interface by the the mocked HttpBackendService expect/when methods
     interface IRequestHandler {

angular-resource/index.d.ts

@@ -162,6 +162,8 @@ declare module 'angular' {
          * Really just a regular Array object with $promise and $resolve attached to it
          */
         interface IResourceArray<T> extends Array<T & IResource<T>> {
+            $cancelRequest(): void;
+
             /** the promise of the original server interaction that created this collection. **/
             $promise: angular.IPromise<IResourceArray<T>>;
             $resolved: boolean;

angular-spinner/angular-spinner-tests.ts

@@ -1,4 +1,4 @@
-
+/// <reference types="angular" />
 
 var myApp = angular.module('testModule');
 

angular-spinner/index.d.ts

@@ -3,23 +3,21 @@
 // Definitions by: Marcin Biegała <https://github.com/Biegal>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="angular" />
-
 /**
-* SpinnerService 
+* SpinnerService
 * see https://github.com/urish/angular-spinner
 */
-interface ISpinnerService {
+declare interface ISpinnerService {
     /**
      * Start selected spinner
-     * 
+     *
      * @param spinner key
      */
     spin(key: string): void;
 
     /**
      * Stop selected spinner
-     * 
+     *
      * @param spinner key
      */
     stop(key: string): void;

angular-strap/index.d.ts

@@ -42,6 +42,7 @@ declare namespace mgcrea.ngStrap {
             show?: boolean;
             container?: string | boolean;
             template?: string;
+            templateUrl?: string;
             contentTemplate?: string;
             prefixEvent?: string;
             id?: string;

angular-ui-bootstrap/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Angular UI Bootstrap 0.13.3
+// Type definitions for Angular UI Bootstrap 0.13.3
 // Project: https://github.com/angular-ui/bootstrap
 // Definitions by: Brian Surowiec <https://github.com/xt0rted>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

angular-ui-router/index.d.ts

@@ -110,7 +110,7 @@ declare module 'angular' {
 
         interface IUrlMatcher {
             concat(pattern: string): IUrlMatcher;
-            exec(path: string, searchParams: {}): {};
+            exec(path: string, search?: any, hash?: string, options?: any): {};
             parameters(): string[];
             format(values: {}): string;
         }

angulartics/angulartics-tests.ts

@@ -10,6 +10,10 @@ namespace Analytics {
             $analyticsProvider.withAutoBase(true);
             $analyticsProvider.developerMode(true);
 
+            $analyticsProvider.trackExceptions(true);
+            $analyticsProvider.trackRoutes(true);
+            $analyticsProvider.trackStates(true);
+
             $analyticsProvider.registerEventTrack((action: string, properties?: any) => {
                 console.log(action);
             });
@@ -19,5 +23,16 @@ namespace Analytics {
             });
 
             $analyticsProvider.settings.pageTracking.basePath = "/my/base/path";
-        }]);
+        }])
+        .run(($analytics: angulartics.IAnalyticsService) => {
+            let isOptedOut = $analytics.getOptOut();
+
+            $analytics.eventTrack('eventName', { label: 'test' });
+            $analytics.pageTrack('/');
+            $analytics.setAlias('alias');
+            $analytics.setOptOut(false);
+            $analytics.setUsername('username');
+            $analytics.setUserProperties({ id: 1 });
+            $analytics.setSuperProperties({ role: 'admin' });
+        });
 }

angulartics/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Angulartics v0.20.2
+// Type definitions for Angulartics v1.3.0
 // Project: http://luisfarzati.github.io/angulartics/
 // Definitions by: Steven Fan <https://github.com/stevenfan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -12,8 +12,10 @@ declare namespace angulartics {
 
     interface IAnalyticsService {
         eventTrack(eventName: string, properties?: any): any;
+        getOptOut(): boolean;
         pageTrack(path:string, location?:angular.ILocationService): any;
         setAlias(alias: string): any;
+        setOptOut(value: boolean): void;
         setUsername(username: string): any;
         setUserProperties(properties: any): any;
         setSuperProperties(properties: any): any;
@@ -26,13 +28,16 @@ declare namespace angulartics {
         withBase(value: boolean): void;
         withAutoBase(value: boolean): void;
         developerMode(value: boolean): void;
+        trackExceptions(value: boolean): void;
+        trackRoutes(value: boolean): void;
+        trackStates(value: boolean): void;
 
         registerPageTrack(callback:(path:string, location?:angular.ILocationService) => any): void;
         registerEventTrack(callback: (eventName: string, properties?: any) => any): void;
-        registerSetAlias(callback: (alias: string) => any): void
-        registerSetUsername(callback: (username: string) => any): void
-        registerSetUserProperties(callback: (userProperties: any) => any): void
-        registerSetSuperProperties(callback: (superProperties: any) => any): void
+        registerSetAlias(callback: (alias: string) => any): void;
+        registerSetUsername(callback: (username: string) => any): void;
+        registerSetUserProperties(callback: (userProperties: any) => any): void;
+        registerSetSuperProperties(callback: (superProperties: any) => any): void;
 
         settings: {
             pageTracking: {

archiver/index.d.ts

@@ -32,7 +32,7 @@ declare namespace archiver {
 
     export interface Archiver extends STREAM.Transform {
         pipe(writeStream: FS.WriteStream): void;
-        append(source: FS.ReadStream | Buffer | string, name: nameInterface): void;
+        append(source: STREAM.Readable | Buffer | string, name: nameInterface): void;
 
         directory(dirpath: string, destpath: nameInterface | string): void;
         directory(dirpath: string, destpath: nameInterface | string, data: any | Function): void;

argon2/argon2-tests.ts

@@ -0,0 +1,35 @@
+
+import { defaults, limits, hash, verify, generateSalt } from 'argon2';
+
+main();
+
+async function main() {
+
+    const defaultTimeCost: number = defaults.timeCost;
+    const defaultMemoryCost: number = defaults.memoryCost;
+    const defaultParallelism: number = defaults.parallelism;
+    const defaultArgon2d: boolean = defaults.argon2d;
+
+    const minMemoryCost: number = limits.memoryCost.min;
+    const maxMemoryCost: number = limits.memoryCost.max;
+    const minTimeCost: number = limits.timeCost.min;
+    const maxTimeCost: number = limits.timeCost.max;
+    const minParallelism: number = limits.parallelism.min;
+    const maxParallelism: number = limits.parallelism.max;
+
+    const options = {
+        timeCost: 4,
+        memoryCost: 13,
+        parallelism: 2,
+        argon2d: true,
+    };
+
+    const hash1: string = await hash('secret', new Buffer(''), options);
+    const hash2: string = await hash('secret', new Buffer(''), {});
+    const hash3: string = await hash('secret', new Buffer(''));
+
+    const verified: boolean = await verify('long-hash', 'secret');
+
+    const salt1: Buffer = await generateSalt();
+    const salt2: Buffer = await generateSalt(32);
+}

argon2/index.d.ts

@@ -0,0 +1,44 @@
+// Type definitions for argon2 0.14
+// Project: https://github.com/ranisalt/node-argon2#readme
+// Definitions by: Peter Safranek <https://github.com/pe8ter>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+declare namespace argon2 {
+
+    export var defaults: {
+        timeCost: number;
+        memoryCost: number;
+        parallelism: number;
+        argon2d: boolean;
+    };
+
+    export var limits: {
+        memoryCost: {
+            min: number;
+            max: number;
+        };
+        timeCost: {
+            min: number;
+            max: number;
+        };
+        parallelism: {
+            min: number;
+            max: number;
+        };
+    };
+
+    export function hash(plain: string, salt: Buffer, options?: {
+        timeCost?: number;
+        memoryCost?: number;
+        parallelism?: number;
+        argon2d?: boolean;
+    }): Promise<string>;
+
+    export function verify(hash: string, plain: string): Promise<boolean>;
+
+    export function generateSalt(length?: number): Promise<Buffer>;
+}
+
+export = argon2;

argon2/tsconfig.json

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

argon2/tslint.json

@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

assert/index.d.ts

@@ -3,7 +3,13 @@
 // Definitions by: vvakame <https://github.com/vvakame>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-// copy from assert external module in node.d.ts
+// Definitions for commonjs-assert match that of node.js' assert module,
+// but commonjs-assert is intended to be used as an independent module,
+// for instance when making a stand-alone site or app that doesn't have
+// access to node modules. For that reason, these definitions define a
+// "assert" module. This will conflict with node.d.ts and other assert
+// modules such as "power-assert", but a project should realistically
+// only be using one of these at a time.
 
 declare function assert(value:any, message?:string):void;
 declare namespace assert {
@@ -50,3 +56,4 @@ declare namespace assert {
 
     export function ifError(value:any):void;
 }
+

async/async-tests.ts

@@ -7,22 +7,23 @@ declare var path: {
     exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
 };
 
+function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
 function callback() { }
 
-async.map(['file1', 'file2', 'file3'], fs.stat, function (err, results) { });
-async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err, results) { });
-async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, function (err, results) { });
+async.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
+async.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
+async.mapLimit(['file1', 'file2', 'file3'], 2, fs.stat, function (err:Error, results:Array<fs.Stats>) { });
 
-async.filter(['file1', 'file2', 'file3'], path.exists, function (results) { });
-async.filterSeries(['file1', 'file2', 'file3'], path.exists, function (results) { });
-async.filterLimit(['file1', 'file2', 'file3'], 2, path.exists, function (results) { });
-async.select(['file1', 'file2', 'file3'], path.exists, function (results) { });
-async.selectSeries(['file1', 'file2', 'file3'], path.exists, function (results) { });
-async.selectLimit(['file1', 'file2', 'file3'], 2, path.exists, function (results) { });
+async.filter(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.filterSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.filterLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.select(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.selectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.selectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
 
-async.reject(['file1', 'file2', 'file3'], path.exists, function (results) { });
-async.rejectSeries(['file1', 'file2', 'file3'], path.exists, function (results) { });
-async.rejectLimit(['file1', 'file2', 'file3'], 2, path.exists, function (results) { });
+async.reject(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.rejectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
+async.rejectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,results:Array<string>) { });
 
 async.parallel([
     function () { },
@@ -46,9 +47,9 @@ var openFilesObj = {
     file2: "fileTwo"
 }
 
-var saveFile = function () { }
-async.each(openFiles, saveFile, function (err) { });
-async.eachSeries(openFiles, saveFile, function (err) { });
+var saveFile = function (file:string,cb:(err:Error)=>void) { }
+async.each(openFiles, saveFile, function (err:Error) { });
+async.eachSeries(openFiles, saveFile, function (err:Error) { });
 
 var documents: any, requestApi: any;
 async.eachLimit(documents, 20, requestApi, function (err) { });
@@ -77,9 +78,9 @@ async.foldl(numArray, 0, reducer, function (err, result) { });
 async.reduceRight(numArray, 0, reducer, function (err, result) { });
 async.foldr(numArray, 0, reducer, function (err, result) { });
 
-async.detect(['file1', 'file2', 'file3'], path.exists, function (result) { });
-async.detectSeries(['file1', 'file2', 'file3'], path.exists, function (result) { });
-async.detectLimit(['file1', 'file2', 'file3'], 2, path.exists, function (result) { });
+async.detect(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err: Error,result:string) { });
+async.detectSeries(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err,result) { });
+async.detectLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err,result) { });
 
 async.sortBy(['file1', 'file2', 'file3'], function (file, callback) {
     fs.stat(file, function (err, stats) {
@@ -87,13 +88,13 @@ async.sortBy(['file1', 'file2', 'file3'], function (file, callback) {
     });
 }, function (err, results) { });
 
-async.some(['file1', 'file2', 'file3'], path.exists, function (result) { });
-async.someLimit(['file1', 'file2', 'file3'], 2, path.exists, function (result) { });
-async.any(['file1', 'file2', 'file3'], path.exists, function (result) { });
+async.some(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,result:boolean) { });
+async.someLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,result:boolean) { });
+async.any(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,result:boolean) { });
 
-async.every(['file1', 'file2', 'file3'], path.exists, function (result) { });
-async.everyLimit(['file1', 'file2', 'file3'], 2, path.exists, function (result) { });
-async.all(['file1', 'file2', 'file3'], path.exists, function (result) { });
+async.every(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,result:boolean) { });
+async.everyLimit(['file1', 'file2', 'file3'], 2, funcStringCbErrBoolean, function (err:Error,result:boolean) { });
+async.all(['file1', 'file2', 'file3'], funcStringCbErrBoolean, function (err:Error,result:boolean) { });
 
 async.concat(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { });
 async.concatSeries(['dir1', 'dir2', 'dir3'], fs.readdir, function (err, files) { });
@@ -111,7 +112,7 @@ async.series([
 ],
 function (err, results) { });
 
-async.series<string>([
+async.series<string,Error>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -135,7 +136,7 @@ async.series({
 },
 function (err, results) { });
 
-async.series<number>({
+async.series<number,Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -175,7 +176,7 @@ async.parallel([
 ],
 function (err, results) { });
 
-async.parallel<string>([
+async.parallel<string,Error>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -204,7 +205,7 @@ async.parallel({
 },
 function (err, results) { });
 
-async.parallel<number>({
+async.parallel<number,Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -270,7 +271,7 @@ async.waterfall([
 ], function (err, result) { });
 
 
-var q = async.queue<any>(function (task: any, callback: any) {
+var q = async.queue<any,Error>(function (task: any, callback: () => void) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -323,7 +324,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = async.queue<string>(function (task: string, callback: any) {
+var q2 = async.queue<string,Error>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -386,10 +387,10 @@ async.retry({ times: 3, interval: (retryCount) => { return 200 * retryCount; } }
 
 
 async.parallel([
-    function (callback) { },
+    function (callback: ( err:Error, val:string ) => void ) { },
     function (callback) { }
 ],
-function (results) {
+function (err:Error,results:Array<string>) {
     async.series([
         function (callback) { },
         function email_link(callback) { }
@@ -442,10 +443,10 @@ async.dir(function (name: string, callback: any) {
 
 // each
 
-async.each<number>({
+async.each<number,Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback): void {
+}, function(val: number, next: ErrorCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -461,10 +462,10 @@ async.each<number>({
 
 });
 
-async.eachSeries<number>({
+async.eachSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback): void {
+}, function(val: number, next: ErrorCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -480,14 +481,14 @@ async.eachSeries<number>({
 
 });
 
-async.eachLimit<number>({
+async.eachLimit<number, Error>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, next: ErrorCallback): void {
+}, 2, function(val: number, next: ErrorCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -505,10 +506,10 @@ async.eachLimit<number>({
 
 // forEachOf/eachOf
 
-async.eachOf<number>({
+async.eachOf<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, key: string, next: ErrorCallback): void {
+}, function(val: number, key: string, next: ErrorCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -524,10 +525,10 @@ async.eachOf<number>({
 
 });
 
-async.forEachOfSeries<number>({
+async.forEachOfSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, key: string, next: ErrorCallback): void {
+}, function(val: number, key: string, next: ErrorCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -543,14 +544,14 @@ async.forEachOfSeries<number>({
 
 });
 
-async.forEachOfLimit<number>({
+async.forEachOfLimit<number, Error>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, key: string, next: ErrorCallback): void {
+}, 2, function(val: number, key: string, next: ErrorCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -568,11 +569,11 @@ async.forEachOfLimit<number>({
 
 // map
 
-async.map<number, string>({
+async.map<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncResultCallback<string>): void {
+}, function(val: number, next: AsyncResultCallback<string, Error>): void {
 
     setTimeout(function(): void {
 
@@ -588,11 +589,11 @@ async.map<number, string>({
 
 });
 
-async.mapSeries<number, string>({
+async.mapSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncResultCallback<string>): void {
+}, function(val: number, next: AsyncResultCallback<string, Error>): void {
 
     setTimeout(function(): void {
 
@@ -608,14 +609,14 @@ async.mapSeries<number, string>({
 
 });
 
-async.mapLimit<number, string>({
+async.mapLimit<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, next: AsyncResultCallback<string>): void {
+}, 2, function(val: number, next: AsyncResultCallback<string, Error>): void {
 
     setTimeout(function(): void {
 
@@ -633,11 +634,11 @@ async.mapLimit<number, string>({
 
 // mapValues
 
-async.mapValues<number, string>({
+async.mapValues<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
+}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
 
     setTimeout(function(): void {
 
@@ -653,11 +654,11 @@ async.mapValues<number, string>({
 
 });
 
-async.mapValuesSeries<number, string>({
+async.mapValuesSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
+}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
 
     setTimeout(function(): void {
 
@@ -675,11 +676,11 @@ async.mapValuesSeries<number, string>({
 
 // filter/select/reject
 
-async.filter<number>({
+async.filter<number, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncBooleanResultCallback): void {
+}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -695,11 +696,11 @@ async.filter<number>({
 
 });
 
-async.reject<number>({
+async.reject<number, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncBooleanResultCallback): void {
+}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
 
     setTimeout(function(): void {
 
@@ -717,11 +718,11 @@ async.reject<number>({
 
 // concat
 
-async.concat<string, string>({
+async.concat<string, string, Error>({
     "a": "1",
     "b": "2",
     "c": "3"
-}, function(item: string, next: AsyncResultCallback<string[]>): void {
+}, function(item: string, next: AsyncResultCallback<string[], Error>): void {
 
     console.log(`async.concat: ${item}`);
 
@@ -735,11 +736,11 @@ async.concat<string, string>({
 
 // detect/find
 
-async.detect<number>({
+async.detect<number, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback): void {
+}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
 
     console.log(`async.detect/find: ${item}`);
 
@@ -760,11 +761,11 @@ async.detect<number>({
 
 // every/all
 
-async.every<number>({
+async.every<number,Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback): void {
+}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
 
     console.log(`async.every/all: ${item}`);
 
@@ -778,11 +779,11 @@ async.every<number>({
 
 // some/any
 
-async.some<number>({
+async.some<number, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback): void {
+}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
 
     console.log(`async.some/any: ${item}`);
 

async/index.d.ts

@@ -5,22 +5,22 @@
 
 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; }
+interface ErrorCallback<T> { (err?: T): void; }
+interface AsyncWaterfallCallback<E> { (err: E, ...args: any[]): void; }
+interface AsyncBooleanResultCallback<E> { (err: E, truthValue: boolean): void; }
+interface AsyncResultCallback<T, E> { (err: E, result: T): void; }
+interface AsyncResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+interface AsyncResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface AsyncFunction<T> { (callback: (err?: Error, result?: T) => void): void; }
-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: AsyncBooleanResultCallback): void; }
+interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
+interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
+interface AsyncMemoIterator<T, R, E> { (memo: R, item: T, callback: AsyncResultCallback<R, E>): void; }
+interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
-interface AsyncWorker<T> { (task: T, callback: ErrorCallback): void; }
-interface AsyncVoidFunction { (callback: ErrorCallback): void; }
+interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+interface AsyncVoidFunction<E> { (callback: ErrorCallback<E>): void; }
 
 interface AsyncQueue<T> {
     length(): number;
@@ -28,10 +28,10 @@ interface AsyncQueue<T> {
     running(): number;
     idle(): boolean;
     concurrency: number;
-    push(task: T, callback?: ErrorCallback): void;
-    push(task: T[], callback?: ErrorCallback): void;
-    unshift(task: T, callback?: ErrorCallback): void;
-    unshift(task: T[], callback?: ErrorCallback): void;
+    push<E>(task: T, callback?: ErrorCallback<E>): void;
+    push<E>(task: T[], callback?: ErrorCallback<E>): void;
+    unshift<E>(task: T, callback?: ErrorCallback<E>): void;
+    unshift<E>(task: T[], callback?: ErrorCallback<E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -53,8 +53,8 @@ interface AsyncPriorityQueue<T> {
     concurrency: number;
     started: boolean;
     paused: boolean;
-    push(task: T, priority: number, callback?: AsyncResultArrayCallback<T>): void;
-    push(task: T[], priority: number, callback?: AsyncResultArrayCallback<T>): void;
+    push<E>(task: T, priority: number, callback?: AsyncResultArrayCallback<T, E>): void;
+    push<E>(task: T[], priority: number, callback?: AsyncResultArrayCallback<T, E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -90,122 +90,122 @@ interface AsyncCargo {
 interface Async {
 
     // Collections
-    each<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    each<T>(arr: Dictionary<T>, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    each<T, E>(arr: T[], iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+    each<T, E>(arr: Dictionary<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
     eachSeries: typeof async.each;
-    eachLimit<T>(arr: T[], limit: number, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    eachLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    eachLimit<T, E>(arr: T[], limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+    eachLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
     forEach: typeof async.each;
     forEachSeries: typeof async.each;
     forEachLimit: typeof async.eachLimit;
-    forEachOf<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    forEachOf<T>(obj: Dictionary<T>, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    forEachOf<T, E>(obj: T[], iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+    forEachOf<T, E>(obj: Dictionary<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
     forEachOfSeries: typeof async.forEachOf;
-    forEachOfLimit<T>(obj: T[], limit: number, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    forEachOfLimit<T>(obj: Dictionary<T>, limit: number, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    forEachOfLimit<T, E>(obj: T[], limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+    forEachOfLimit<T, E>(obj: Dictionary<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
     eachOf: typeof async.forEachOf;
     eachOfSeries: typeof async.forEachOf;
     eachOfLimit: typeof async.forEachOfLimit;
-    map<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): void;
-    map<T, R>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): void;
+    map<T, R, E>(arr: T[], iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+    map<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
     mapSeries: typeof async.map;
-    mapLimit<T, R>(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;
+    mapLimit<T, R, E>(arr: T[], limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+    mapLimit<T, R, E>(arr: Dictionary<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+    mapValuesLimit<T, R, E>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultCallback<R[], E>): void;
+    mapValues<T, R, E>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultCallback<R[], E>): void;
     mapValuesSeries: typeof async.mapValues;
-    filter<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): void;
-    filter<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultArrayCallback<T>): void;
+    filter<T, E>(arr: T[], iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+    filter<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
     filterSeries: typeof async.filter;
-    filterLimit<T>(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;
+    filterLimit<T, E>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+    filterLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
     select: typeof async.filter;
     selectSeries: typeof async.filter;
     selectLimit: typeof async.filterLimit;
     reject: typeof async.filter;
     rejectSeries: typeof async.filter;
     rejectLimit: typeof async.filterLimit;
-    reduce<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): void;
+    reduce<T, R, E>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
     inject: typeof async.reduce;
     foldl: typeof async.reduce;
     reduceRight: typeof async.reduce;
     foldr: typeof async.reduce;
-    detect<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): void;
-    detect<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncResultCallback<T>): void;
+    detect<T, E>(arr: T[], iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+    detect<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
     detectSeries: typeof async.detect;
-    detectLimit<T>(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;
+    detectLimit<T, E>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+    detectLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
     find: typeof async.detect;
     findSeries: typeof async.detect;
     findLimit: typeof async.detectLimit;
-    sortBy<T, V>(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;
+    sortBy<T, V, E>(arr: T[], iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+    some<T, E>(arr: T[], iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+    some<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
     someSeries: typeof async.some;
-    someLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
-    someLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    someLimit<T, E>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+    someLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
     any: typeof async.some;
     anySeries: typeof async.someSeries;
     anyLimit: typeof async.someLimit;
-    every<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
-    every<T>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    every<T, E>(arr: T[], iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+    every<T, E>(arr: Dictionary<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
     everySeries: typeof async.every;
-    everyLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
-    everyLimit<T>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T>, callback?: AsyncBooleanResultCallback): void;
+    everyLimit<T, E>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+    everyLimit<T, E>(arr: Dictionary<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
     all: typeof async.every;
     allSeries: typeof async.every;
     allLimit: typeof async.everyLimit;
 
-    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;
+    concat<T, R, E>(arr: T[], iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+    concat<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
     concatSeries: typeof async.concat;
 
     // Control Flow
-    series<T>(tasks: AsyncFunction<T>[], callback?: AsyncResultArrayCallback<T>): void;
-    series<T>(tasks: Dictionary<AsyncFunction<T>>, callback?: AsyncResultObjectCallback<T>): void;
-    parallel<T>(tasks: Array<AsyncFunction<T>>, callback?: AsyncResultArrayCallback<T>): void;
-    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: 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;
+    series<T, E>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
+    series<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+    parallel<T, E>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
+    parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+    parallelLimit<T, E>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
+    parallelLimit<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
+    whilst<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+    doWhilst<E>(fn: AsyncVoidFunction<E>, test: () => boolean, callback: ErrorCallback<E>): void;
+    until<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+    doUntil<E>(fn: AsyncVoidFunction<E>, test: () => boolean, callback: ErrorCallback<E>): void;
+    during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+    doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
+    forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
+    waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T,E>): void;
     compose(...fns: Function[]): Function;
     seq(...fns: Function[]): Function;
     applyEach(fns: Function[], argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
     applyEachSeries(fns: Function[], argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-    queue<T>(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?: 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>;
+    queue<T, E>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
+    priorityQueue<T, E>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
+    cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
+    auto<E>(tasks: any, concurrency?: number, callback?: AsyncResultCallback<any, E>): void;
+    autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
+    retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
+    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
+    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
+    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E>;
     nextTick(callback: Function, ...args: any[]): void;
     setImmediate: typeof async.nextTick;
 
-    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)[];
+    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: void, result: {error?: Error, value?: T}) => void) => void;
+    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: void, result: {error?: Error, value?: T}) => void) => void)[];
 
-    timeout<T>(fn: AsyncFunction<T>, milliseconds: number, info: any): AsyncFunction<T>;
+    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info: any): AsyncFunction<T, E>;
 
-    times<T> (n: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
-    timesSeries<T>(n: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
-    timesLimit<T>(n: number, limit: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
+    times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+    timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+    timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
-    transform<T, R>(arr: T[], iteratee: (acc: R[], item: T, key: string, callback: (error?: Error) => void) => void): void;
-    transform<T, R>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: string, callback: (error?: Error) => void) => void): void;
-    transform<T, R>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: Error) => void) => void): void;
-    transform<T, R>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: Error) => void) => void): void;
+    transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
+    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
+    transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): void;
+    transform<T, R, E>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): void;
 
-    race<T>(tasks: (AsyncFunction<T>)[], callback: AsyncResultCallback<T>) : void;
+    race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E>) : void;
 
     // Utils
     memoize(fn: Function, hasher?: Function): Function;

atpl/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for atpl
+// Type definitions for atpl
 // Project: https://github.com/soywiz/atpl.js
 // Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

auth0-angular/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for auth0-angular
+// Type definitions for auth0-angular
 // Project: https://github.com/auth0/auth0-angular
 // Definitions by: Matt Emory <https://github.com/homesar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

auth0-js/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Auth0.js
+// Type definitions for Auth0.js
 // Project: https://github.com/auth0/auth0.js
 // Definitions by: Robert McLaws <https://github.com/advancedrei>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -22,7 +22,7 @@ interface Auth0Static {
     logout(query: string): void;
     getConnections(callback?: Function): void;
     refreshToken(refreshToken: string, callback: (error?: Auth0Error, delegationResult?: Auth0DelegationToken) => any): void;
-    getDelegationToken(targetClientId: string, id_token: string, options: any, callback: (error?: Auth0Error, delegationResult?: Auth0DelegationToken) => any): void;
+    getDelegationToken(options: any, callback: (error?: Auth0Error, delegationResult?: Auth0DelegationToken) => any): void;
     getProfile(id_token: string, callback?: Function): Auth0UserProfile;
     getSSOData(withActiveDirectories: any, callback?: Function): void;
     parseHash(hash: string): Auth0DecodedHash;
@@ -84,7 +84,7 @@ interface Auth0Identity {
 
 interface Auth0DecodedHash {
     access_token: string;
-    id_token: string;
+    idToken: string;
     profile: Auth0UserProfile;
     state: any;
 }
@@ -96,6 +96,7 @@ interface Auth0PopupOptions {
 
 interface Auth0LoginOptions {
     auto_login?: boolean;
+    responseType?: string;
     connection?: string;
     email?: string;
     username?: string;

auth0-lock/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for auth0-lock v10.0.1
+// Type definitions for auth0-lock v10.0.1
 // Project: http://auth0.com
 // Definitions by: Brian Caruso <https://github.com/carusology>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

auth0.widget/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Auth0Widget.js
+// Type definitions for Auth0Widget.js
 // Project: http://auth0.com
 // Definitions by: Robert McLaws <https://github.com/advancedrei>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

auth0/auth0-tests.ts

@@ -49,3 +49,30 @@ auth
   }).catch((err) => {
     // Handle the error.
   });
+
+
+// Update a user
+management
+  .updateUser({id: "user_id"}, {"email": "hi@me.co"});
+
+// Update a user using callback
+management
+  .updateUser({id: "user_id"}, {"email": "hi@me.co"}, (err: Error, users: auth0.User) => {});
+
+
+// Update user metadata
+management
+  .updateUserMetadata({id: "user_id"}, {"key": "value"});
+
+// Update user metadata using callback
+management
+  .updateUserMetadata({id: "user_id"}, {"key": "value"}, (err: Error, users: auth0.User) => {});
+
+
+// Update app metadata
+management
+  .updateAppMetadata({id: "user_id"}, {"key": "value"});
+
+// Update app metadata using callback
+management
+  .updateAppMetadata({id: "user_id"}, {"key": "value"}, (err: Error, users: auth0.User) => {});

auth0/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for auth0 v2.3.1
+// Type definitions for auth0 v2.3.1
 // Project: https://github.com/auth0/node-auth0
 // Definitions by: Seth Westphal <https://github.com/westy92>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -10,15 +10,18 @@ export interface ManagementClientOptions {
   domain?: string;
 }
 
+export type UserMetadata = {};
+export type AppMetadata = {};
+
 export interface UserData {
   connection: string;
   email?: string;
   username?: string;
   password?: string;
   phone_number?: string;
-  user_metadata?: {};
+  user_metadata?: UserMetadata;
   email_verified?: boolean;
-  app_metadata?: {};
+  app_metadata?: AppMetadata;
 }
 
 export interface GetUsersData {
@@ -43,8 +46,8 @@ export interface User {
   created_at?: string;
   updated_at?: string;
   identities?: Identity[];
-  app_metadata?: {};
-  user_metadata?: {};
+  app_metadata?: AppMetadata;
+  user_metadata?: UserMetadata;
   picture?: string;
   name?: string;
   nickname?: string;
@@ -53,6 +56,8 @@ export interface User {
   last_login?: string;
   logins_count?: number;
   blocked?: boolean;
+  given_name?: string;
+  family_name?: string;
 }
 
 export interface Identity {
@@ -62,6 +67,10 @@ export interface Identity {
   isSocial: boolean;
 }
 
+export interface UpdateUserParameters {
+  id: string;
+}
+
 export class ManagementClient {
   constructor(options: ManagementClientOptions);
 
@@ -69,6 +78,12 @@ export class ManagementClient {
   getUsers(params?: GetUsersData, cb?: (err: Error, users: User[]) => void): void;
   createUser(data: UserData): Promise<User>;
   createUser(data: UserData, cb: (err: Error, data: User) => void): void;
+  updateUser(params: UpdateUserParameters, data: User): Promise<User>;
+  updateUser(params: UpdateUserParameters, data: User, cb: (err: Error, data: User) => void): void;
+  updateUserMetadata(params: UpdateUserParameters, data: UserMetadata): Promise<User>;
+  updateUserMetadata(params: UpdateUserParameters, data: UserMetadata, cb: (err: Error, data: User) => void): void
+  updateAppMetadata(params: UpdateUserParameters, data: AppMetadata): Promise<User>;
+  updateAppMetadata(params: UpdateUserParameters, data: AppMetadata, cb: (err: Error, data: User) => void): void
 }
 
 export interface AuthenticationClientOptions {
@@ -86,4 +101,4 @@ export class AuthenticationClient {
 
   requestChangePasswordEmail(data: RequestChangePasswordEmailData): Promise<string>;
   requestChangePasswordEmail(data: RequestChangePasswordEmailData, cb: (err: Error, message: string) => void): void;
-}
+}

aws-iot-device-sdk/aws-iot-device-sdk-tests.ts

@@ -0,0 +1,103 @@
+// Code adapted from
+// https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b468d59e02e2f6a1dce321000d914cb47894/examples/device-example.js
+// and
+// https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b468d59e02e2f6a1dce321000d914cb47894/examples/thing-example.js
+
+import * as awsIot from "aws-iot-device-sdk";
+import * as mqtt from "mqtt";
+
+const device = new awsIot.device({
+  keyPath: "",
+  certPath: "",
+  caPath: "",
+  clientId: "",
+  region: "",
+  baseReconnectTimeMs: 1000,
+  keepalive: 10,
+  protocol: "wss",
+  port: 443,
+  host: "",
+  debug: false
+});
+
+device.subscribe("topic_1");
+
+device
+      .on("connect", function() {
+         console.log("connect");
+      });
+   device
+      .on("close", function() {
+         console.log("close");
+      });
+   device
+      .on("reconnect", function() {
+         console.log("reconnect");
+      });
+   device
+      .on("offline", function() {
+         console.log("offline");
+      });
+   device
+      .on("error", function(error) {
+         console.log("error", error);
+      });
+   device
+      .on("message", function(topic: string, payload: any) {
+         console.log("message", topic, payload.toString());
+      });
+
+
+const thingShadows = new awsIot.thingShadow({
+    keyPath: "",
+    certPath: "",
+    caPath: "",
+    clientId: "",
+    region: "",
+    baseReconnectTimeMs: 1000,
+    keepalive: 10,
+    protocol: "mqtts",
+    port: 0,
+    host: "",
+    debug: false
+ });
+
+ thingShadows.register(
+   "thingName",
+   { ignoreDeltas: false },
+   (err: Error, failedTopics: mqtt.Granted[]) => { }
+ );
+
+ thingShadows.on("connect", function() {
+     console.log("connected to AWS IoT");
+  });
+
+  thingShadows.on("close", function() {
+     console.log("close");
+     thingShadows.unregister("thingName");
+  });
+
+  thingShadows.on("reconnect", function() {
+     console.log("reconnect");
+  });
+
+  thingShadows.on("offline", function() {
+     console.log("offline");
+  });
+
+  thingShadows.on("error", function(error) {
+     console.log("error", error);
+  });
+
+  thingShadows.on("message", function(topic: string, payload: any) {
+     console.log("message", topic, payload.toString());
+  });
+
+  thingShadows.on("status", function(thingName: string, stat: "accepted" | "rejected", clientToken: string, stateObject: any) {
+  });
+
+  thingShadows.on("delta", function(thingName, stateObject) {
+  });
+
+  thingShadows.on("timeout", function(thingName, clientToken) {
+  });

aws-iot-device-sdk/index.d.ts

@@ -0,0 +1,396 @@
+// Type definitions for aws-iot-device-sdk 1.0.13
+// Project: https://github.com/aws/aws-iot-device-sdk-js
+// Definitions by: Markus Olsson <https://github.com/niik>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import * as mqtt from "mqtt";
+import * as WebSocket from "ws";
+
+export interface DeviceOptions extends mqtt.ClientOptions {
+  /** the AWS IoT region you will operate in (default "us-east-1") */
+  region?: string;
+
+  /** the client ID you will use to connect to AWS IoT */
+  clientId?: string;
+
+  /**
+   * path of the client certificate file path of the private key file
+   * associated with the client certificate
+   */
+  certPath?: string;
+
+  /** path of the private key file associated with the client certificate */
+  keyPath?: string;
+
+  /** path of your CA certificate file */
+  caPath?: string;
+
+  /**
+   * same as certPath, but can also accept a buffer containing client
+   * certificate data
+   */
+  clientCert?: string;
+
+  /**
+   * same as keyPath, but can also accept a buffer containing private key
+   * data
+   */
+  privateKey?: string;
+
+  /**
+   * same as caPath, but can also accept a buffer containing CA certificate
+   * data
+   */
+  caCert?: string;
+
+  /**
+   * set to "true" to automatically re-subscribe to topics after
+   * reconnection (default "true")
+   */
+  autoResubscribe?: boolean;
+
+  /** set to "true" to automatically queue published messages while
+   * offline (default "true")
+   */
+  offlineQueueing?: boolean;
+
+  /**
+   * enforce a maximum size for the offline message queue
+   * (default 0, e.g. no maximum)
+   */
+  offlineQueueMaxSize?: number;
+
+  /**
+   * set to "oldest" or "newest" to define drop behavior on a full
+   * queue when offlineQueueMaxSize > 0
+   */
+  offlineQueueDropBehavior?: "oldest" | "newest";
+
+  /**
+   * the minimum time in milliseconds between publishes when draining
+   * after reconnection (default 250)
+   */
+  drainTimeMs?: number;
+
+  /** the base reconnection time in milliseconds (default 1000) */
+  baseReconnectTimeMs?: number;
+
+  /** the maximum reconnection time in milliseconds (default 128000) */
+  maximumReconnectTimeMs?: number;
+
+  /**
+   * the minimum time in milliseconds that a connection must be maintained
+   * in order to be considered stable (default 20000)
+   */
+  minimumConnectionTimeMs?: number;
+
+  /**
+   * the connection type, either "mqtts" (default) or "wss" (WebSocket/TLS).
+   * Note that when set to "wss", values must be provided for the
+   * Access Key ID and Secret Key in either the following options or in
+   * environment variables as specified in WebSocket Configuration[1].
+   *
+   * 1. https://github.com/aws/aws-iot-device-sdk-js#websockets
+   */
+  protocol?: "mqtts" | "wss";
+  /**
+   * if protocol is set to "wss", you can use this parameter to pass
+   * additional options to the underlying WebSocket object;
+   * these options are documented here.
+   */
+  websocketOptions?: WebSocket.IClientOptions;
+
+  /**
+   * used to specify the Access Key ID when protocol is set to "wss".
+   * Overrides the environment variable AWS_ACCESS_KEY_ID if set.
+   */
+  accessKeyId?: string;
+  /**
+   * used to specify the Secret Key when protocol is set to "wss".
+   * Overrides the environment variable AWS_SECRET_ACCESS_KEY if set.
+   */
+  secretKey?: string;
+  /**
+   * (required when authenticating via Cognito, optional otherwise) used
+   * to specify the Session Token when protocol is set to "wss". Overrides
+   * the environment variable AWS_SESSION_TOKEN if set.
+   */
+  sessionToken?: string;
+
+  /**
+   * optional hostname, if not specified a hostname will be constructed
+   * from the region option
+   */
+  // NB Not documented but present in examples, see
+  // https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b468d/device/index.js#L376
+  // https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b468d/device/index.js#L149
+  host?: string;
+
+  /** optional port, will be appended to hostname if present and not 443 */
+  // NB Not documented but present in examples, see
+  // https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b468d/device/index.js#L154
+  port?: number;
+
+  /** enable console logging, default false */
+  // NB Not documented but present in examples, see
+  // https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b468d/device/index.js#L436
+  debug?: boolean;
+}
+
+export class device extends NodeJS.EventEmitter {
+  /**
+   * Returns a wrapper for the mqtt.Client() class, configured for a TLS
+   * connection with the AWS IoT platform and with arguments as specified
+   * in options.
+   */
+  constructor(options?: DeviceOptions);
+
+  /**
+   * Update the credentials set used to authenticate via WebSocket/SigV4.
+   *
+   * This method is designed to be invoked during the callback of the
+   * getCredentialsForIdentity method in the AWS SDK for JavaScript.
+   */
+  updateWebSocketCredentials(accessKeyId: string, secretKey: string, sessionToken: string, expiration: Date): void;
+
+  on(event: "connect" | "close" | "reconnect" | "offline", listener: () => void): this;
+
+  // Error | string comes from:
+  // https://github.com/aws/aws-iot-device-sdk-js/blob/97b0b46/device/index.js#L744
+  // Remove when https://github.com/aws/aws-iot-device-sdk-js/issues/95 is fixed
+  on(event: "error", listener: (error: Error | string) => void): this;
+
+  /** Emitted when a message is received on a topic not related to any Thing Shadows */
+  on(event: "message", listener: (topic: string, payload: any) => void): this;
+
+  // The following publish, subscribe, unsubscribe and end Definitions
+  // are derived from the mqtt definition as they are re-surfaced through
+  // thingShadow
+  // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/e7772769fab8c206449ce9673cac417370330aa9/mqtt/mqtt.d.ts#L199
+
+  /**
+   * Publish a message to a topic
+   *
+   * @param topic to publish to
+   * @param message to publish
+   * @param publish options
+   * @param called when publish succeeds or fails
+   */
+  publish(topic: string, message: Buffer | string, options?: mqtt.ClientPublishOptions, callback?: (error?: Error) => void): mqtt.Client;
+
+  /**
+   * Subscribe to a topic or topics
+   * @param topic to subscribe to or an Array of topics to subscribe to. It can also be an object.
+   * @param the options to subscribe with
+   * @param callback fired on suback
+   */
+  subscribe(topic: string | string[] | mqtt.Topic, options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+
+  /**
+   * Unsubscribe from a topic or topics
+   *
+   * @param topic  is a String topic or an array of topics to unsubscribe from
+   * @param options
+   * @param callback  fired on unsuback
+   */
+  unsubscribe(topic: string | string[], options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+
+  /**
+   * end - close connection
+   *
+   * @param force passing it to true will close the client right away, without waiting for the in-flight messages to be acked.
+   *     This parameter is optional.
+   * @param callback
+   */
+  end(force?: boolean, callback?: Function): mqtt.Client;
+}
+
+export interface ThingShadowOptions extends DeviceOptions {
+  /** the timeout for thing operations (default 10 seconds) */
+  operationTimeout?: number;
+}
+
+export interface RegisterOptions {
+  /**
+   * set to true to not subscribe to the delta sub-topic for this
+   * Thing Shadow; used in cases where the application is not interested in
+   * changes (e.g. update only.) (default false)
+   */
+  ignoreDeltas?: boolean;
+
+  /**
+   * set to false to unsubscribe from all operation sub-topics while not
+   * performing an operation (default true)
+   */
+  persistentSubscribe?: boolean;
+
+  /**
+   * set to false to allow receiving messages with old version
+   * numbers (default true)
+   */
+  discardStale?: boolean;
+
+  /** set to true to send version numbers with shadow updates (default true) */
+  enableVersioning?: boolean;
+}
+
+/**
+ * The thingShadow class wraps an instance of the device class with
+ * additional functionality to operate on Thing Shadows via the AWS IoT API.
+ */
+export class thingShadow extends NodeJS.EventEmitter {
+
+  constructor(options?: ThingShadowOptions);
+
+  /**
+   * Register interest in the Thing Shadow named thingName.
+   *
+   * The thingShadow class will subscribe to any applicable topics, and will
+   * fire events for the Thing Shadow until awsIot.thingShadow#unregister()
+   * is called with thingName
+   *
+   * If the callback parameter is provided, it will be invoked after
+   * registration is complete (i.e., when subscription ACKs have been received
+   * for all shadow topics). Applications should wait until shadow
+   * registration is complete before performing update/get/delete operations.
+   */
+  register(thingName: string, options?: RegisterOptions, callback?: (error: Error, failedTopics: mqtt.Granted[]) => void): void
+
+  /**
+   * Unregister interest in the Thing Shadow named thingName.
+   *
+   * The thingShadow class will unsubscribe from all applicable topics
+   * and no more events will be fired for thingName.
+   */
+  unregister(thingName: string): void
+
+  /**
+   * Update the Thing Shadow named thingName with the state specified in the
+   * JavaScript object stateObject. thingName must have been previously
+   * registered using awsIot.thingShadow#register().
+   *
+   * The thingShadow class will subscribe to all applicable topics and
+   * publish stateObject on the update sub-topic.
+   *
+   * This function returns a clientToken, which is a unique value associated
+   * with the update operation. When a "status" or "timeout" event is emitted,
+   * the clientToken will be supplied as one of the parameters, allowing the
+   * application to keep track of the status of each operation. The caller may
+   * create their own clientToken value; if stateObject contains a clientToken
+   * property, that will be used rather than the internally generated value.
+   * Note that it should be of atomic type (i.e. numeric or string).
+   * This function returns "null" if an operation is already in progress.
+   */
+  update(thingName: string, stateObject: any): string | null;
+
+  /**
+   * Get the current state of the Thing Shadow named thingName, which must
+   * have been previously registered using awsIot.thingShadow#register().
+   * The thingShadow class will subscribe to all applicable topics and
+   * publish on the get sub-topic.
+   *
+   * This function returns a clientToken, which is a unique value
+   * associated with the get operation. When a "status or "timeout" event
+   * is emitted, the clientToken will be supplied as one of the parameters,
+   * allowing the application to keep track of the status of each operation.
+   * The caller may supply their own clientToken value (optional); if
+   * supplied, the value of clientToken will be used rather than the
+   * internally generated value. Note that this value should be of atomic
+   * type (i.e. numeric or string). This function returns "null" if an
+   * operation is already in progress.
+   */
+  get(thingName: string, clientToken?: string): string | null;
+
+  /**
+   * Delete the Thing Shadow named thingName, which must have been previously
+   * registered using awsIot.thingShadow#register(). The thingShadow class
+   * will subscribe to all applicable topics and publish on the delete sub-topic.
+   *
+   * This function returns a clientToken, which is a unique value associated
+   * with the delete operation. When a "status" or "timeout" event is
+   * emitted, the clientToken will be supplied as one of the parameters,
+   * allowing the application to keep track of the status of each operation.
+   * The caller may supply their own clientToken value (optional); if
+   * supplied, the value of clientToken will be used rather than the
+   * internally generated value. Note that this value should be of atomic
+   * type (i.e. numeric or string). This function returns "null" if an
+   * operation is already in progress.
+   */
+  delete(thingName: string, clientToken?: string): string | null;
+
+  // The following publish, subscribe, unsubscribe and end Definitions
+  // are copied from the mqtt definition as they are re-surfaced through
+  // thingShadow
+  // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/e7772769fab8c206449ce9673cac417370330aa9/mqtt/mqtt.d.ts#L199
+
+  /**
+   * Publish a message to a topic
+   *
+   * @param topic
+   * @param message
+   * @param options
+   * @param callback
+   */
+  publish(topic: string, message: Buffer, options?: mqtt.ClientPublishOptions, callback?: Function): mqtt.Client;
+  publish(topic: string, message: string, options?: mqtt.ClientPublishOptions, callback?: Function): mqtt.Client;
+
+  /**
+   * Subscribe to a topic or topics
+   * @param topic to subscribe to or an Array of topics to subscribe to. It can also be an object.
+   * @param the options to subscribe with
+   * @param callback fired on suback
+   */
+  subscribe(topic: string, options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+  subscribe(topic: string[], options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+  subscribe(topic: mqtt.Topic, options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+
+  /**
+   * Unsubscribe from a topic or topics
+   *
+   * @param topic  is a String topic or an array of topics to unsubscribe from
+   * @param options
+   * @param callback  fired on unsuback
+   */
+  unsubscribe(topic: string, options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+  unsubscribe(topic: string[], options?: mqtt.ClientSubscribeOptions, callback?: mqtt.ClientSubscribeCallback): mqtt.Client;
+
+  /**
+   * end - close connection
+   *
+   * @param force passing it to true will close the client right away, without waiting for the in-flight messages to be acked.
+   *     This parameter is optional.
+   * @param callback
+   */
+  end(force?: boolean, callback?: Function): mqtt.Client;
+
+  on(event: "connect" | "close" | "reconnect" | "offline", listener: () => void): this;
+  on(event: "error", listener: (error: Error) => void): this;
+
+  /** Emitted when a message is received on a topic not related to any Thing Shadows */
+  on(event: "message", listener: (topic: string, payload: any) => void): this;
+
+  /**
+   * Emitted when an operation update|get|delete completes.
+   *
+   * thingName - name of the Thing Shadow for which the operation has completed
+   * stat - status of the operation accepted|rejected
+   * clientToken - the operation"s clientToken
+   * stateObject - the stateObject returned for the operation
+   *
+   * Applications can use clientToken values to correlate status events with
+   * the operations that they are associated with by saving the clientTokens
+   * returned from each operation.
+   */
+  on(event: "status", listener: (thingName: string, operationStatus: "accepted" | "rejected", clientToken: string, stateObject: any) => void): this;
+
+  /** Emitted when an operation update|get|delete has timed out. */
+  on(event: "timeout", listener: (thingName: string, clientToken: string) => void): this;
+
+  /** Emitted when a delta has been received for a registered Thing Shadow. */
+  on(event: "delta", listener: (thingName: string, stateObject: any) => void): this;
+
+  /** Emitted when a different client"s update or delete operation is accepted on the shadow. */
+  on(event: "foreignStateChange", listener: (thingName: string, operation: "update" | "delete", stateObject: any) => void): this;
+}

aws-iot-device-sdk/tsconfig.json

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

aws4/index.d.ts

@@ -30,4 +30,4 @@ export class RequestSigner {
     formatPath(): string;
 }
 
-export function sign(options?: any, credentials?: any): RequestSigner;
+export function sign(options?: any, credentials?: any): any;

axios/axios-tests.ts

@@ -80,7 +80,11 @@ var axiosInstance = axios.create({
     timeout: 1000
 });
 
-axiosInstance.request({url: "issues/1"});
+axiosInstance.request({url: "issues/1"}).then(res => {
+    if (res.headers['content-type'].startsWith('application/json')) {
+        throw new Error('Unexpected content-type');
+    }
+});
 
 axios.all<Repository, Repository>([getRepoDetails, getRepoDetails]).then(([repo1, repo2]) => {
     var sumIds = repo1.data.id + repo2.data.id;

axios/index.d.ts

@@ -159,7 +159,7 @@ declare namespace Axios {
         /**
          * headers that the server responded with
          */
-        headers: Object;
+        headers: {[index: string]: any};
 
         /**
          * config that was provided to `axios` for the request

azure-mobile-apps/index.d.ts

@@ -237,7 +237,7 @@ declare namespace Azure.MobileApps {
     interface SqlParameterDefinition {
         name: string;
         value: any;
-    }
+     }		     
 
     interface TableDefinition {
         access?: AccessType;

babylon/index.d.ts

@@ -43,5 +43,5 @@ export interface BabylonOptions {
 
 export type PluginName = 'jsx' | 'flow' | 'asyncFunctions' | 'classConstructorCall' | 'doExpressions'
     | 'trailingFunctionCommas' | 'objectRestSpread' | 'decorators' | 'classProperties' | 'exportExtensions'
-    | 'exponentiationOperator' | 'asyncGenerators' | 'functionBind' | 'functionSent';
+    | 'exponentiationOperator' | 'asyncGenerators' | 'functionBind' | 'functionSent' | '*';
 

backbone.radio/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Backbone.Radio v0.8.3
+// Type definitions for Backbone.Radio v0.8.3
 // Project: https://github.com/marionettejs/backbone.radio
 // Definitions by: Peter Palotas <https://github.com/alphaleonis/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bcrypt/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bcrypt
+// Type definitions for bcrypt
 // Project: https://www.npmjs.org/package/bcrypt
 // Definitions by: Peter Harris <https://github.com/codeanimal>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bgiframe/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bgiframe 1.0
+// Type definitions for bgiframe 1.0
 // Project: https://github.com/sumegizoltan/BgiFrame
 // Definitions by: Zoltan Sumegi <https://github.com/sumegizoltan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bigint/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for BigInt v5.5.3
+// Type definitions for BigInt v5.5.3
 // Project: https://github.com/Evgenus/BigInt
 // Definitions by: Eugene Chernyshov <https://github.com/Evgenus>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bingmaps/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Microsoft.Maps 7.0
+// Type definitions for Microsoft.Maps 7.0
 // Project: http://msdn.microsoft.com/en-us/library/gg427611.aspx
 // Definitions by: Eric Todd <https://github.com/ericrtodd>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bintrees/bintrees-tests.ts

@@ -0,0 +1,14 @@
+import { BinTree, RBTree } from 'bintrees';
+
+let treeA = new RBTree((a:number, b:number) => a - b);
+
+treeA.insert(5);
+treeA.insert(3);
+treeA.remove(3);
+
+let treeB = new BinTree((a:string, b:string) => a.length - b.length);
+
+treeB.insert('hi');
+treeB.insert('there');
+treeB.insert('how');
+treeB.insert('are');

bintrees/index.d.ts

@@ -0,0 +1,61 @@
+// Type definitions for bintrees 1.0.1
+// Project: https://github.com/vadimg/js_bintrees
+// Definitions by: Cayle Sharrock <https://github.com/CjS77>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module 'bintrees' {
+
+    type Callback = <T>(err: Error, item: T) => void;
+    type Comparator = <T>(a: T, b: T) => number;
+
+    class Iterator<T> {
+        constructor(tree: TreeBase<T>);
+
+        data(): T;
+
+        next(): T;
+
+        prev(): T;
+    }
+
+    class TreeBase<T> {
+        size: number;
+
+        clear(): void;
+
+        find(data: T): T;
+
+        findIter(data: T): Iterator<T>;
+
+        lowerBound(item: T): Iterator<T>;
+
+        upperBound(item: T): Iterator<T>;
+
+        min(): T;
+
+        max(): T;
+
+        iterator(): Iterator<T>;
+
+        each(cb: Callback): void;
+
+        reach(cb: Callback): void;
+    }
+
+
+    export class RBTree<T> extends TreeBase<T> {
+        constructor(comparator: Comparator);
+
+        insert(item: T): boolean;
+
+        remove(item: T): boolean;
+    }
+
+    export class BinTree<T> extends TreeBase<T> {
+        constructor(comparator: Comparator);
+
+        insert(item: T): boolean;
+
+        remove(item: T): boolean;
+    }
+}

bintrees/tsconfig.json

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

bitwise-xor/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bitwise-xor 0.0.0
+// Type definitions for bitwise-xor 0.0.0
 // Project: https://github.com/czzarr/node-bitwise-xor
 // Definitions by: Rogier Schouten <https://github.com/rogierschouten>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bluebird-retry/index.d.ts

@@ -16,6 +16,7 @@ declare namespace retry {
         max_interval?: number;
         timeout?: number;
         max_tries?: number;
+        predicate?: any;
     }
 
 }

bluebird/bluebird-tests.ts

@@ -336,6 +336,29 @@ fooOrBarProm = fooProm.caught(Promise.CancellationError, (reason: any) => {
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+{
+	class CustomError extends Error {
+		public customField: number;
+	}
+	fooProm = fooProm.catch(CustomError, reason => {
+		let a: number = reason.customField
+	})
+}
+
+{
+	class CustomErrorWithConstructor extends Error {
+		constructor(public arg1: boolean, public arg2: number) {
+			super();
+		};
+	}
+	fooProm = fooProm.catch(CustomErrorWithConstructor, reason => {
+		let a: boolean = reason.arg1;
+		let b: number = reason.arg2;
+	})
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
 barProm = fooProm.error((reason: any) => {
 	return bar;
 });

bluebird/index.d.ts

@@ -65,14 +65,19 @@ declare class Bluebird<R> implements Bluebird.Thenable<R>, Bluebird.Inspection<R
    */
   catch(predicate: (error: any) => boolean, onReject: (error: any) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
   caught(predicate: (error: any) => boolean, onReject: (error: any) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
+  
   catch<U>(predicate: (error: any) => boolean, onReject: (error: any) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
   caught<U>(predicate: (error: any) => boolean, onReject: (error: any) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
-  catch(ErrorClass: Function, onReject: (error: any) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
-  caught(ErrorClass: Function, onReject: (error: any) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
-  catch<U>(ErrorClass: Function, onReject: (error: any) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
-  caught<U>(ErrorClass: Function, onReject: (error: any) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
+  
+  catch<E extends Error>(ErrorClass: new (...args: any[]) => E, onReject: (error: E) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
+  caught<E extends Error>(ErrorClass: new (...args: any[]) => E, onReject: (error: E) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
+
+  catch<E extends Error, U>(ErrorClass: new (...args: any[]) => E, onReject: (error: E) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
+  caught<E extends Error, U>(ErrorClass: new (...args: any[]) => E, onReject: (error: E) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
+  
   catch(predicate: Object, onReject: (error: any) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
   caught(predicate: Object, onReject: (error: any) => R | Bluebird.Thenable<R> | void | Bluebird.Thenable<void>): Bluebird<R>;
+  
   catch<U>(predicate: Object, onReject: (error: any) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
   caught<U>(predicate: Object, onReject: (error: any) => U | Bluebird.Thenable<U>): Bluebird<U | R>;
 

bootstrap-fileinput/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bootstrap-fileinput
+// Type definitions for bootstrap-fileinput
 // Project: https://github.com/kartik-v/bootstrap-fileinput
 // Definitions by: Ché Coxshall <https://github.com/CheCoxshall>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bootstrap-switch/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Bootstrap Switch
+// Type definitions for Bootstrap Switch
 // Project: http://www.bootstrap-switch.org/
 // Definitions by: John M. Baughman <https://github.com/johnmbaughman>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bootstrap-touchspin/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Bootstrap TouchSpin
+// Type definitions for Bootstrap TouchSpin
 // Project: http://www.virtuosoft.eu/code/bootstrap-touchspin/
 // Definitions by: Albin Sunnanbo <https://github.com/albinsunnanbo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bootstrap.timepicker/index.d.ts

@@ -5,9 +5,12 @@
 
 /// <reference types="jquery"/>
 
-interface TimeickerOptions {
-    defaultTime?: string;
+interface TimepickerOptions {
+    defaultTime?: string|boolean;
     disableFocus?: boolean;
+    disableMousewheel?: boolean;
+    explicitMode?: boolean;
+    icons?: TimepickerIconOptions;
     isOpen?: boolean;
     minuteStep?: number;
     modalBackdrop?: boolean;
@@ -15,13 +18,32 @@ interface TimeickerOptions {
     showSeconds?: boolean;
     showInputs?: boolean;
     showMeridian?: boolean;
-    template?: string;
+    template?: string|boolean;
     appendWidgetTo?: string;
+    maxHours?: number;
+    snapToStep?: boolean;
+}
+
+interface TimepickerIconOptions {
+    up?: string;
+    down?: string;
+}
+
+interface TimepickerTime {
+    value?: string;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    meridian?: string;
 }
 
 interface JQuery {
     timepicker(): JQuery;
     timepicker(methodName: string): JQuery;
     timepicker(methodName: string, params: any): JQuery;
-    timepicker(options: TimeickerOptions): JQuery;
+    timepicker(options: TimepickerOptions): JQuery;
+}
+
+interface JQueryEventObject extends BaseJQueryEventObject, JQueryInputEventObject, JQueryMouseEventObject, JQueryKeyEventObject {
+    time?: TimepickerTime;
 }

bootstrap.v3.datetimepicker/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Bootstrap 3 Datepicker v4.17.37
+// Type definitions for Bootstrap 3 Datepicker v4.17.37
 // Project: http://eonasdan.github.io/bootstrap-datetimepicker
 // Definitions by: Katona Péter <https://github.com/katonap>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

braintree-web/index.d.ts

@@ -97,7 +97,7 @@ declare namespace BraintreeWeb {
 //  billingContact
 //  Billing contact information for the user.
 //    countryCode
-//Required.The merchant’s two- letter ISO 3166 country code.
+//Required.The merchant’s two- letter ISO 3166 country code.
 //    currencyCode
 //  Required.The three- letter ISO 4217 currency code for the payment.
 //    lineItems
@@ -782,7 +782,7 @@ declare namespace BraintreeWeb {
      * });
      * @returns {void}
      */
-    on(event: string, handler: (() => any)): void;
+    on(event: string, handler: ((event: any) => any)): void;
 
     /**
      * Cleanly tear down anything set up by {@link module:braintree-web/hosted-fields.create|create}
@@ -1740,4 +1740,4 @@ interface BraintreeStatic {
   VERSION: string;
 }
 
-declare var braintree: BraintreeStatic;
+declare var braintree: BraintreeStatic;

bunyan-prettystream/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bunyan-prettystream 0.1.3
+// Type definitions for bunyan-prettystream 0.1.3
 // Project: https://www.npmjs.com/package/bunyan-prettystream
 // Definitions by: Jason Swearingen <https://github.com/jasonswearingen/>, Vadim Macagon <https://github.com/enlight/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

bunyan/index.d.ts

@@ -11,7 +11,7 @@ import { EventEmitter } from 'events';
 declare class Logger extends EventEmitter {
     constructor(options: LoggerOptions);
     addStream(stream: Stream): void;
-        addSerializers(serializers:Serializers | StdSerializers):void;
+    addSerializers(serializers:Serializers | StdSerializers):void;
     child(options: LoggerOptions, simple?: boolean): Logger;
     child(obj: Object, simple?: boolean): Logger;
     reopenFileStreams(): void;
@@ -56,20 +56,21 @@ interface LoggerOptions {
     stream?: NodeJS.WritableStream;
     serializers?: Serializers | StdSerializers;
     src?: boolean;
+    [custom: string]: any;
 }
 
-	interface Serializer {
-		(input:any): any;
-	}
+interface Serializer {
+    (input:any): any;
+}
 
 interface Serializers {
-        [key:string]: Serializer;
-    }
+    [key: string]: Serializer
+}
 
-    interface StdSerializers {
-        err: Serializer;
-        res: Serializer;
-        req: Serializer;
+interface StdSerializers {
+    err: Serializer;
+    res: Serializer;
+    req: Serializer;
 }
 
 interface Stream {
@@ -82,7 +83,7 @@ interface Stream {
     count?: number;
 }
 
-    export var stdSerializers:StdSerializers;
+export declare var stdSerializers: StdSerializers;
 
 export declare var TRACE: number;
 export declare var DEBUG: number;

bytes/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bytes v2.4.0
+// Type definitions for bytes v2.4.0
 // Project: https://github.com/visionmedia/bytes.js
 // Definitions by: Zhiyuan Wang <https://github.com/danny8002/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

cal-heatmap/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for cal-heatmap v3.5.4
+// Type definitions for cal-heatmap v3.5.4
 // Project: https://github.com/wa0x6e/cal-heatmap
 // Definitions by: Chris Baker <https://github.com/RetroChrisB/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

canvasjs/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for CanvasJS v1.5.1
+// Type definitions for CanvasJS v1.5.1
 // Project: http://canvasjs.com/
 // Definitions by: Mark Overholt <https://github.com/mover5>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

cassandra-driver/index.d.ts

@@ -134,7 +134,7 @@ export namespace types {
   var LocalTime: LocalTimeStatic;
   var Long: _Long;
   var ResultSet: ResultSetStatic;
-    // var ResultStream: ResultStreamStatic;
+  // var ResultStream: ResultStreamStatic;
   var Row: RowStatic;
   var TimeUuid: TimeUuidStatic;
   var Tuple: TupleStatic;

chai-oequal/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for chai-oequal
+// Type definitions for chai-oequal 0.0
 // Project: https://github.com/wrwrwr/chai-oequal
 // Definitions by: Mizunashi Mana <https://github.com/mizunashi-mana>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -23,5 +23,6 @@ declare namespace Chai {
 
 declare module 'chai-oequal' {
     function chaiOequal(chai: any, utils: any): void;
+    namespace chaiOequal {}
     export = chaiOequal;
 }

chosen/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Chosen.JQuery 1.6.1
+// Type definitions for Chosen.JQuery 1.6.1
 // Project: http://harvesthq.github.com/chosen/
 // Definitions by: Boris Yankov <https://github.com/borisyankov/>, denis <https://github.com/denisname/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

chrome/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Chrome extension development
+// Type definitions for Chrome extension development
 // Project: http://developer.chrome.com/extensions/
 // Definitions by: Matthew Kimber <https://github.com/matthewkimber>, otiai10 <https://github.com/otiai10>, couven92 <https://github.com/couven92>, RReverser <https://github.com/rreverser>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

ckeditor/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for CKEditor
+// Type definitions for CKEditor
 // Project: http://ckeditor.com/
 // Definitions by: Ondrej Sevcik <https://github.com/ondrejsevcik/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

cli-color/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for cli-color 0.3.2
+// Type definitions for cli-color 0.3.2
 // Project: https://github.com/medikoo/cli-color
 // Definitions by: Joel Spadin <https://github.com/ChaosinaCan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

codemirror/codemirror-tests.ts

@@ -48,5 +48,9 @@ myCodeMirror.getValue();
 myCodeMirror.getValue("foo")
 myCodeMirror.setValue("bar");
 
-CodeMirror.registerHelper("lint", "javascript", {});
+myCodeMirror.on(
+  "renderLine",
+  (instance: CodeMirror.Editor, line: CodeMirror.LineHandle, element: HTMLElement) => { }
+);
 
+CodeMirror.registerHelper("lint", "javascript", {});

codependency/codependency-tests.ts

@@ -0,0 +1,11 @@
+/// <reference path="index.d.ts" />
+/// <reference types="node" />
+
+let requirePeer = codependency.register(module), package: any;
+    requirePeer = codependency.register(module, {index: ["dependencies", "devDependencies"]});
+    requirePeer = codependency.get("some-middleware");
+    package = requirePeer("some-peer-dependency-package");
+    package = requirePeer("some-peer-dependency-package", {optional: true});
+    package = requirePeer("some-peer-dependency-package", {dontThrow: true});
+    package = requirePeer("some-peer-dependency-package", {optional: true, dontThrow: true});
+    package = requirePeer.resolve("peer-package-name");

codependency/index.d.ts

@@ -0,0 +1,29 @@
+// Type definitions for codependency v0.1.3
+// Project: https://github.com/Wizcorp/codependency
+// Definitions by: Morgan Benton <https://github.com/morphatic>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+export as namespace codependency;
+
+interface DependencyInfo {
+    supportedRange: string|null;
+    installedVersion: string|null;
+    isInstalled: boolean|null;
+    isValid: boolean|null;
+    pkgPath: string;
+}
+
+interface RequirePeerFunctionOptions {
+    optional?: boolean;
+    dontThrow?: boolean;
+}
+
+interface RequirePeerFunction {
+    (name: string, options?: RequirePeerFunctionOptions): any;
+    resolve: (name: string) => DependencyInfo;
+}
+
+export function register(baseModule: NodeModule, options?: {index: string[]}): RequirePeerFunction;
+export function get(middlewareName: string): RequirePeerFunction;

codependency/package.json

@@ -0,0 +1,5 @@
+{
+    "dependencies": {
+        "@types/node": "^6.0.0"
+    }
+}

codependency/tsconfig.json

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