From b4fc6f27dc2bcf91c31d536539fe4f48becd18d1 Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Mon, 9 Jan 2017 05:24:31 +0100
Subject: [PATCH 01/87] Jest update

---
 jest/index.d.ts    | 68 +++++++++++++++++++++++++++++++++++----
 jest/jest-tests.ts | 79 +++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 140 insertions(+), 7 deletions(-)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index fda6c66404..6e3d5381a8 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -1,7 +1,8 @@
-// Type definitions for Jest 16.0.0
+// Type definitions for Jest 18.0.0
 // Project: http://facebook.github.io/jest/
-// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>
+// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>, Alexey Svetliakov <https://github.com/asvetliakov>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 declare var beforeAll: jest.Lifecycle;
 declare var beforeEach: jest.Lifecycle;
@@ -16,7 +17,7 @@ declare var xit: jest.It;
 declare var test: jest.It;
 declare var xtest: jest.It;
 
-declare function expect(actual: any): jest.Matchers;
+declare const expect: jest.Expect;
 
 interface NodeRequire {
     /** Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not. */
@@ -31,8 +32,10 @@ declare namespace jest {
     function autoMockOff(): typeof jest;
     /** Enables automatic mocking in the module loader. */
     function autoMockOn(): typeof jest;
-    /** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
+    /** @deprecated */
     function clearAllMocks(): typeof jest;
+    /** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
+    function resetAllMocks(): typeof jest;
     /** Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future. */
     function clearAllTimers(): typeof jest;
     /** Indicates that the module system should never return a mocked version of the specified module, including all of the specificied module's dependencies. */
@@ -111,6 +114,41 @@ declare namespace jest {
         skip: Describe;
     }
 
+    interface MatcherUtils {
+        readonly isNot: boolean;
+        utils: {
+            readonly EXPECTED_COLOR: string;
+            readonly RECEIVED_COLOR: string;
+            ensureActualIsNumber(actual: any, matcherName?: string): void;
+            ensureExpectedIsNumber(actual: any, matcherName?: string): void;
+            ensureNoExpected(actual: any, matcherName?: string): void;
+            ensureNumbers(actual: any, expected: any, matcherName?: string): void;
+            /** get the type of a value with handling the edge cases like `typeof []` and `typeof null` */
+            getType(value: any): string;
+            matcherHint(matcherName: string, received?: string, expected?: string, options?: { secondArgument?: string, isDirectExpectCall?: boolean }): string;
+            pluralize(word: string, count: number): string;
+            printExpected(value: any): string;
+            printReceived(value: any): string;
+            printWithType(name: string, received: any, print: (value: any) => string): string;
+            stringify(object: {}, maxDepth?: number): string;
+        }
+    }
+
+    interface ExpectExtendMap {
+        [key: string]: (this: MatcherUtils, received: any, actual: any) => { message: () => string, pass: boolean };
+    }
+
+    interface Expect {
+        (actual: any): Matchers;
+        anything(): void;
+        any(cs: any): void;
+        arrayContaining(arr: any[]): void;
+        assertions(num: number): void;
+        extend(obj: ExpectExtendMap): void;
+        objectContaining(obj: {}): void;
+        stringMatching(str: string | RegExp): void;
+    }
+
     interface Matchers {
         not: Matchers;
         lastCalledWith(...args: any[]): void;
@@ -135,9 +173,11 @@ declare namespace jest {
         toHaveBeenCalledTimes(expected: number): boolean;
         toHaveBeenCalledWith(...params: any[]): boolean;
         toHaveBeenLastCalledWith(...params: any[]): boolean;
+        toHaveLength(expected: number): void;
+        toHaveProperty(propertyPath: string, value?: any): void;
         toMatch(expected: string | RegExp): void;
         toMatchObject(expected: {}): void;
-        toMatchSnapshot(): void;
+        toMatchSnapshot(snapshotName?: string): void;
         toThrow(): void;
         toThrowError(error?: string | Constructable | RegExp): void;
         toThrowErrorMatchingSnapshot(): void;
@@ -147,9 +187,25 @@ declare namespace jest {
         new (...args: any[]): any
     }
 
-    interface Mock<T> extends Function {
+    interface Mock<T> extends Function, MockInstance<T> {
         new (): T;
         (...args: any[]): any;
+    }
+
+    /**
+     * Wrap module with mock definitions
+     * @example
+     *  jest.mock("../api");
+     *  import { Api } from "../api";
+     *
+     *  const myApi: jest.Mocked<Api> = new Api() as any;
+     *  myApi.myApiMethod.mockImplementation(() => "test");
+     */
+    type Mocked<T> = T & {
+        [P in keyof T]: T[P] & MockInstance<T>;
+    } & MockInstance<T>;
+
+    interface MockInstance<T> {
         mock: MockContext<T>;
         mockClear(): void;
         mockImplementation(fn: Function): Mock<T>;
diff --git a/jest/jest-tests.ts b/jest/jest-tests.ts
index 913a671fa1..e1f8fb120f 100644
--- a/jest/jest-tests.ts
+++ b/jest/jest-tests.ts
@@ -171,6 +171,60 @@ describe('toThrow API', function () {
    });
 });
 
+describe('Assymetric matchers', function () {
+    it('works', function () {
+        expect({
+            timestamp: 1480807810388,
+            text: 'Some text content, but we care only about *this part*'
+        }).toEqual({
+            timestamp: expect.any(Number),
+            text: expect.stringMatching('*this part*')
+        });
+
+        const callback = jest.fn();
+        expect(callback).toEqual(expect.any(Function));
+        callback(5, "test");
+        expect(callback).toBeCalledWith(expect.any(Number), expect.any(String))
+        const obj = {
+            items: [1]
+        };
+        expect(obj).toEqual(expect.objectContaining({
+            items: expect.arrayContaining([
+                expect.any(Number)
+            ])
+        }));
+
+        expect.assertions(4);
+    });
+});
+
+describe('Extending extend', function () {
+    it('works', function () {
+        expect.extend({
+            toBeNumber(received: any, actual: any) {
+                const pass = received === actual;
+                const message =
+                    () => `expected ${received} ${pass ? 'not ' : ''} to be ${actual}`;
+                return { message, pass };
+            },
+            toBeTest(received: any, actual: any) {
+                this.utils.ensureNoExpected(received);
+                this.utils.ensureActualIsNumber(received);
+                this.utils.ensureExpectedIsNumber(actual);
+                this.utils.ensureNumbers(received, actual);
+
+                return {
+                    message: () => `
+                    ${this.utils.getType(received).toLowerCase()} \n\n
+                    ${this.utils.matcherHint(".not.toBe")} ${this.utils.printExpected(actual)} ${this.utils.printReceived(received)}\n\n
+                    `,
+                    pass: true
+                };
+            }
+        });
+    });
+});
+
 describe('missing tests', function () {
     it('creates closures', function () {
        class Closure<T> {
@@ -208,7 +262,7 @@ describe('missing tests', function () {
        expect(getFruits()).toContain('Orange');
        mock.mockReturnValueOnce(['Apple', 'Plum']);
        expect(mock()).not.toContain('Orange');
-       const myBeverage: any = {delicious: true, sour: false}; 
+       const myBeverage: any = {delicious: true, sour: false};
        expect(myBeverage).toContainEqual({delicious: true, sour: false});
        mock.mockReturnValue([]); //Deprecated: Use jest.fn(() => value) instead.
        mock.mockClear();
@@ -248,6 +302,10 @@ describe('toMatchSnapshot', function () {
    it('compares snapshots', function () {
         expect({ type: 'a', props: { href: 'https://www.facebook.com/' }, children: [ 'Facebook' ] }).toMatchSnapshot();
     });
+
+   it('can give name to snapshot', function () {
+        expect({ type: 'a', props: { href: 'https://www.facebook.com/' }, children: [ 'Facebook' ] }).toMatchSnapshot('given name');
+   });
 });
 
 describe('toThrowErrorMatchingSnapshot', function () {
@@ -367,3 +425,22 @@ describe('strictNullChecks', function () {
         done();
     })
 });
+
+interface TestApi {
+    testProp: boolean;
+    testMethod(a: number): void;
+}
+
+describe("Mocked type", function () {
+    it("Works", function () {
+        const mock: jest.Mocked<TestApi> = jest.fn(() => ({
+            testProp: true,
+            testMethod1: jest.fn(),
+            testMethod2: jest.fn()
+        })) as any;
+        mock.testProp;
+        mock.testMethod.mockImplementation(() => "test");
+        mock.testMethod(5);
+        mock.mockClear();
+    });
+});

From f2581e2b98d07073207ab3e5685dc44c5435ca32 Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Mon, 9 Jan 2017 06:59:08 +0100
Subject: [PATCH 02/87] Added one more example for jest.Mocked

---
 jest/index.d.ts    | 5 +++++
 jest/jest-tests.ts | 6 ++++++
 2 files changed, 11 insertions(+)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index 6e3d5381a8..2f246f2bfe 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -200,6 +200,11 @@ declare namespace jest {
      *
      *  const myApi: jest.Mocked<Api> = new Api() as any;
      *  myApi.myApiMethod.mockImplementation(() => "test");
+     *
+     *  jest.mock("./func");
+     *  const myFuncMock: jest.Mocked<typeof myFunc> = require("./func");
+     *  myFuncMock.mockImplementation(() => 5);
+     *  myFuncMock();
      */
     type Mocked<T> = T & {
         [P in keyof T]: T[P] & MockInstance<T>;
diff --git a/jest/jest-tests.ts b/jest/jest-tests.ts
index e1f8fb120f..f2866d1689 100644
--- a/jest/jest-tests.ts
+++ b/jest/jest-tests.ts
@@ -431,6 +431,8 @@ interface TestApi {
     testMethod(a: number): void;
 }
 
+declare function mockedFunc(a: number): string;
+
 describe("Mocked type", function () {
     it("Works", function () {
         const mock: jest.Mocked<TestApi> = jest.fn(() => ({
@@ -442,5 +444,9 @@ describe("Mocked type", function () {
         mock.testMethod.mockImplementation(() => "test");
         mock.testMethod(5);
         mock.mockClear();
+
+        const funcMock: jest.Mocked<typeof mockedFunc> = require("./mockedFunc");
+        funcMock.mockImplementation(() => "test");
+        funcMock(5).toUpperCase();
     });
 });

From 3e757ce66287de54c45ecb30945c869ce7ad9809 Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Mon, 9 Jan 2017 20:26:28 +0100
Subject: [PATCH 03/87] Infer type for jest.fn() for subtypes of object

---
 jest/index.d.ts    |  1 +
 jest/jest-tests.ts | 43 ++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index 2f246f2bfe..e81a08c1ca 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -49,6 +49,7 @@ declare namespace jest {
     /** Enables automatic mocking in the module loader. */
     function enableAutomock(): typeof jest;
     /** Creates a mock function. Optionally takes a mock implementation. */
+    function fn<T extends {}>(implementation: (...args: any[]) => T): Mock<T>;
     function fn<T>(implementation?: Function): Mock<T>;
     /** Use the automatic mocking system to generate a mocked version of the given module. */
     function genMockFromModule<T>(moduleName: string): T;
diff --git a/jest/jest-tests.ts b/jest/jest-tests.ts
index f2866d1689..c42df8fef4 100644
--- a/jest/jest-tests.ts
+++ b/jest/jest-tests.ts
@@ -433,20 +433,53 @@ interface TestApi {
 
 declare function mockedFunc(a: number): string;
 
-describe("Mocked type", function () {
-    it("Works", function () {
+describe('Mocked type', function () {
+    it('Works', function () {
         const mock: jest.Mocked<TestApi> = jest.fn(() => ({
             testProp: true,
             testMethod1: jest.fn(),
             testMethod2: jest.fn()
         })) as any;
         mock.testProp;
-        mock.testMethod.mockImplementation(() => "test");
+        mock.testMethod.mockImplementation(() => 'test');
         mock.testMethod(5);
         mock.mockClear();
 
-        const funcMock: jest.Mocked<typeof mockedFunc> = require("./mockedFunc");
-        funcMock.mockImplementation(() => "test");
+        const funcMock: jest.Mocked<typeof mockedFunc> = require('./mockedFunc');
+        funcMock.mockImplementation(() => 'test');
         funcMock(5).toUpperCase();
     });
 });
+
+describe('Mocks', function () {
+    it('jest.fn() without args is a function type', function () {
+        const test = jest.fn();
+        test();
+        new test();
+        test.mock.instances[0];
+        test.mockImplementation(() => { });
+    });
+
+    it('jest.fn() with returned object infers type', function () {
+        const testMock = jest.fn(() => ({ a: 5, test: jest.fn() }));
+
+        testMock(5, 5, 'a');
+        testMock.mockImplementation(() => { });
+        testMock.caller;
+
+        const ins = new testMock();
+        ins.a;
+        ins.test();
+        ins.test.mockImplementation(() => 5);
+        ins.test.mock.calls;
+
+        const anotherMock = jest.fn(() => {
+            const api: Partial<TestApi> = {
+                testMethod: jest.fn()
+            };
+            return api;
+        });
+        const anotherIns: jest.Mocked<TestApi> = new anotherMock() as any;
+        anotherIns.testMethod.mockImplementation(() => 1);
+    });
+});

From 654c2b4e117145df33183ebb67a9f9938e2937e6 Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Wed, 11 Jan 2017 06:36:08 +0100
Subject: [PATCH 04/87] Fix Mocked type

---
 jest/index.d.ts    |  7 +------
 jest/jest-tests.ts | 18 +++++-------------
 2 files changed, 6 insertions(+), 19 deletions(-)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index e81a08c1ca..020376004b 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -201,15 +201,10 @@ declare namespace jest {
      *
      *  const myApi: jest.Mocked<Api> = new Api() as any;
      *  myApi.myApiMethod.mockImplementation(() => "test");
-     *
-     *  jest.mock("./func");
-     *  const myFuncMock: jest.Mocked<typeof myFunc> = require("./func");
-     *  myFuncMock.mockImplementation(() => 5);
-     *  myFuncMock();
      */
     type Mocked<T> = T & {
         [P in keyof T]: T[P] & MockInstance<T>;
-    } & MockInstance<T>;
+    };
 
     interface MockInstance<T> {
         mock: MockContext<T>;
diff --git a/jest/jest-tests.ts b/jest/jest-tests.ts
index c42df8fef4..d2fcd6d007 100644
--- a/jest/jest-tests.ts
+++ b/jest/jest-tests.ts
@@ -426,28 +426,20 @@ describe('strictNullChecks', function () {
     })
 });
 
-interface TestApi {
+class TestApi {
+    constructor() { };
     testProp: boolean;
-    testMethod(a: number): void;
+    testMethod(a: number): string { return ""; }
 }
 
 declare function mockedFunc(a: number): string;
 
 describe('Mocked type', function () {
     it('Works', function () {
-        const mock: jest.Mocked<TestApi> = jest.fn(() => ({
-            testProp: true,
-            testMethod1: jest.fn(),
-            testMethod2: jest.fn()
-        })) as any;
+        const mock: jest.Mocked<TestApi> = new TestApi() as any;
         mock.testProp;
         mock.testMethod.mockImplementation(() => 'test');
-        mock.testMethod(5);
-        mock.mockClear();
-
-        const funcMock: jest.Mocked<typeof mockedFunc> = require('./mockedFunc');
-        funcMock.mockImplementation(() => 'test');
-        funcMock(5).toUpperCase();
+        mock.testMethod(5).toUpperCase();
     });
 });
 

From 004db1e2c6dd5795264b2e98e67f0a579f44d42d Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Fri, 13 Jan 2017 05:09:16 +0100
Subject: [PATCH 05/87] Added mockReset()

---
 jest/index.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index 020376004b..acfe70a0f6 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -209,6 +209,7 @@ declare namespace jest {
     interface MockInstance<T> {
         mock: MockContext<T>;
         mockClear(): void;
+        mockReset(): void;
         mockImplementation(fn: Function): Mock<T>;
         mockImplementationOnce(fn: Function): Mock<T>;
         mockReturnThis(): Mock<T>;

From 65701d7b2b3d60b309a7acd2fda6c10d2a77aec1 Mon Sep 17 00:00:00 2001
From: Pablo Moleri <pmoleri@infragistics.com>
Date: Wed, 18 Jan 2017 14:03:23 -0300
Subject: [PATCH 06/87] Fix getLocation return type

Also renamed GeoLocation type because it was being merged with Location type.
---
 webdriverio/index.d.ts | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/webdriverio/index.d.ts b/webdriverio/index.d.ts
index fbc6925fa9..f033ec2bfc 100644
--- a/webdriverio/index.d.ts
+++ b/webdriverio/index.d.ts
@@ -352,36 +352,37 @@ declare namespace WebdriverIO {
         ): Client<P>;
         getHTML<P>(includeSelectorTag: boolean): Client<P>;
 
-        getLocation(selector?: string): Size;
-        getLocation(selector: string, axis: string): number;
-        getLocation(axis: string): number;
+        getLocation(selector?: string): Location;
+        getLocation(selector: string, axis: Axis): number;
+        getLocation(axis: Axis): number;
         getLocation<P>(selector?: string): Client<P>;
         getLocation<P>(
             selector: string,
-            axis: string
+            axis: Axis
         ): Client<P>;
-        getLocation<P>(axis: string): Client<P>;
+        getLocation<P>(axis: Axis): Client<P>;
 
-        getLocationInView(selector: string): Size;
-        getLocationInView(selector: string): Size[];
-        getLocationInView(): Size;
-        getLocationInView(): Size[];
+        getLocationInView(selector: string): Location;
+        getLocationInView(selector: string): Location[];
+        getLocationInView(): Location;
+        getLocationInView(): Location[];
         getLocationInView(
             selector: string,
-            axis: string
+            axis: Axis
         ): number;
         getLocationInView(
             selector: string,
-            axis: string
+            axis: Axis
         ): number[];
-        getLocationInView(axis: string): number;
-        getLocationInView(axis: string): number[];
+        getLocationInView(axis: Axis): number;
+        getLocationInView(axis: Axis): number[];
         getLocationInView<P>(selector?: string): Client<P>;
         getLocationInView<P>(
             selector: string,
-            axis: string
+            axis: Axis
         ): Client<P>;
-        getLocationInView<P>(axis: string): Client<P>;
+        getLocationInView<P>(axis: Axis): Client<P>;
+
 
         getSource(): Client<string>;
         getSource<P>(): Client<P>;
@@ -428,7 +429,7 @@ declare namespace WebdriverIO {
         value: any;
     }
 
-    export interface Location {
+    export interface GeoLocation {
         latitude: number;
         longitude: number;
         altitude: number;
@@ -983,6 +984,8 @@ declare namespace WebdriverIO {
         switchTab<P>(windowHandle?: string): Client<P>;
     }
 
+    export type Axis = "x" | "y";
+
     export interface Options {
         protocol: string;
         waitforTimeout: number;

From fac57d46263790b607f28881422aa9aac55d750c Mon Sep 17 00:00:00 2001
From: Jonathan Jayet <jonathan@artus.io>
Date: Thu, 19 Jan 2017 16:00:50 +0100
Subject: [PATCH 07/87] Fix a small issue withing the multer typing

---
 multer/index.d.ts | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/multer/index.d.ts b/multer/index.d.ts
index 2437f498db..1e388f7630 100644
--- a/multer/index.d.ts
+++ b/multer/index.d.ts
@@ -48,22 +48,22 @@ declare namespace multer {
         /** A function used to determine within which folder the uploaded files should be stored. Defaults to the system's default temporary directory. */
         destination?: string | ((req: Express.Request, file: Express.Multer.File, callback: (error: Error, destination: string) => void) => void);
         /** A function used to determine what the file should be named inside the folder. Defaults to a random name with no file extension. */
-        filename?: (req: Express.Request, file: Express.Multer.File, callback: (error: Error, filename: string) => void) => void;
+        filename?: (req: Express.Request, file: Express.Multer.File, callback: (error?: Error, filename?: string) => void) => void;
     }
 
     interface Instance {
-            /** In case you need to handle a text-only multipart form, you can use any of the multer methods (.single(), .array(), fields()), req.body contains the text fields */
-            single(): express.RequestHandler;
-            /** Accept a single file with the name fieldname. The single file will be stored in req.file. */
-            single(fieldame: string): express.RequestHandler;
-            /** In case you need to handle a text-only multipart form, you can use any of the multer methods (.single(), .array(), fields()), req.body contains the text fields */
-            array(): express.RequestHandler;
-            /** Accept an array of files, all with the name fieldname. Optionally error out if more than maxCount files are uploaded. The array of files will be stored in req.files. */
-            array(fieldame: string, maxCount?: number): express.RequestHandler;
-            /** Accept a mix of files, specified by fields. An object with arrays of files will be stored in req.files. */
-            fields(fields: Field[]): express.RequestHandler;
-            /** In case you need to handle a text-only multipart form, you can use any of the multer methods (.single(), .array(), fields()), req.body contains the text fields */
-            any(): express.RequestHandler;
+        /** In case you need to handle a text-only multipart form, you can use any of the multer methods (.single(), .array(), fields()), req.body contains the text fields */
+        single(): express.RequestHandler;
+        /** Accept a single file with the name fieldname. The single file will be stored in req.file. */
+        single(fieldame: string): express.RequestHandler;
+        /** In case you need to handle a text-only multipart form, you can use any of the multer methods (.single(), .array(), fields()), req.body contains the text fields */
+        array(): express.RequestHandler;
+        /** Accept an array of files, all with the name fieldname. Optionally error out if more than maxCount files are uploaded. The array of files will be stored in req.files. */
+        array(fieldame: string, maxCount?: number): express.RequestHandler;
+        /** Accept a mix of files, specified by fields. An object with arrays of files will be stored in req.files. */
+        fields(fields: Field[]): express.RequestHandler;
+        /** In case you need to handle a text-only multipart form, you can use any of the multer methods (.single(), .array(), fields()), req.body contains the text fields */
+        any(): express.RequestHandler;
     }
 }
 

From c779cebd7f18a885b1e956020d884438c1e5566e Mon Sep 17 00:00:00 2001
From: Jonathan Jayet <jonathan@artus.io>
Date: Thu, 19 Jan 2017 16:07:39 +0100
Subject: [PATCH 08/87] Better typing yet

---
 multer/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/multer/index.d.ts b/multer/index.d.ts
index 1e388f7630..53fdcd7add 100644
--- a/multer/index.d.ts
+++ b/multer/index.d.ts
@@ -48,7 +48,7 @@ declare namespace multer {
         /** A function used to determine within which folder the uploaded files should be stored. Defaults to the system's default temporary directory. */
         destination?: string | ((req: Express.Request, file: Express.Multer.File, callback: (error: Error, destination: string) => void) => void);
         /** A function used to determine what the file should be named inside the folder. Defaults to a random name with no file extension. */
-        filename?: (req: Express.Request, file: Express.Multer.File, callback: (error?: Error, filename?: string) => void) => void;
+        filename?: (req: Express.Request, file: Express.Multer.File, callback: (error: Error | null, filename: string) => void) => void;
     }
 
     interface Instance {

From e76c78bd71ea47bb417a853950844b9b320b86f9 Mon Sep 17 00:00:00 2001
From: Sergei Dorogin <github@dorogin.com>
Date: Thu, 19 Jan 2017 21:26:35 +0300
Subject: [PATCH 09/87] jquery.fileupload

added JQueryFileUploadXhr.headers field
---
 jquery.fileupload/index.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/jquery.fileupload/index.d.ts b/jquery.fileupload/index.d.ts
index 8eba9853b2..54ebb89c5c 100644
--- a/jquery.fileupload/index.d.ts
+++ b/jquery.fileupload/index.d.ts
@@ -284,6 +284,7 @@ interface JQueryFileUploadXhr {
     jqXHR: JQueryXHR;
     result: any;
     textStatus: string;
+    headers: {[key: string]: any};
 }
 
 interface JQueryFileUploadFilesObject {

From 567657e3fab839bdeb535ea23c6593cbc8ce7588 Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Thu, 19 Jan 2017 15:29:50 +0300
Subject: [PATCH 10/87] Added types for SIP.js

---
 SIP.js/SIP.js-tests.ts |  99 ++++++++++++
 SIP.js/index.d.ts      | 354 +++++++++++++++++++++++++++++++++++++++++
 SIP.js/tsconfig.json   |  23 +++
 SIP.js/tslint.json     |   1 +
 4 files changed, 477 insertions(+)
 create mode 100644 SIP.js/SIP.js-tests.ts
 create mode 100644 SIP.js/index.d.ts
 create mode 100644 SIP.js/tsconfig.json
 create mode 100644 SIP.js/tslint.json

diff --git a/SIP.js/SIP.js-tests.ts b/SIP.js/SIP.js-tests.ts
new file mode 100644
index 0000000000..f688fe67ae
--- /dev/null
+++ b/SIP.js/SIP.js-tests.ts
@@ -0,0 +1,99 @@
+import SIP = require("./index");
+
+let ua: SIP.UA = new SIP.UA();
+
+const mediaHandler = (session: SIP.Session, options: SIP.WebRTC.Options) => new SIP.WebRTC.MediaHandler();
+const logConnector = (level: string, category: string, label: string, content: string) => null;
+
+const uaWithConfig: SIP.UA = new SIP.UA({
+    uri: "wss://uri",
+    wsServers: ["s1", "s2"],
+    allowLegacyNotifications: true,
+    authenticationFactory: mediaHandler,
+    authorizationUser: "user",
+    autostart: true,
+    connectionRecoveryMaxInterval: 1,
+    connectionRecoveryMinInterval: 1,
+    displayName: "name",
+    hackCleanJitsiSdpImageattr: true,
+    hackStripTcp: true,
+    hackIpInContact: true,
+    hackViaTcp: true,
+    hackWssInTransport: true,
+    iceCheckingTimeout: 1,
+    instanceId: "id",
+    log: {
+        builtinEnabled: true,
+        level: 1,
+        connector: logConnector
+    },
+    mediaHandlerFactory: mediaHandler,
+    noAnswerTimeout: 1,
+    password: "",
+    register: true,
+    registerExpires: 1,
+    registrarServer: "sip:registrar.mydomain.com",
+    rel100: "",
+    replaces: "",
+    stunServers: ["", ""],
+    turnServers: [
+        {
+            password: "", 
+            username: "",
+            urls: ["", ""]
+        }
+    ],
+    usePreloadedRoute: true,
+    userAgentString: "",
+    wsServerMaxReconnection: 1,
+    wsServerReconnectionTimeout: 1
+});
+
+ua.start();
+ua.stop();
+
+ua.register();
+ua = ua.register({ extraHeaders: [""] });
+
+ua.unregister()
+ua.unregister({ extraHeaders: [""], all: true });
+
+const isConnected: boolean = ua.isConnected();
+const isRegistered: boolean = ua.isRegistered();
+
+const message: SIP.Message = ua.message("", "", { contentType: "" });
+
+ua.subscribe("", "", { expires: 1, extraHeaders: [""]});
+const subscription: SIP.Subscription = ua.subscribe(new SIP.URI(), "", { expires: 1, extraHeaders: [""]});
+
+let session = ua.invite("", new HTMLVideoElement());
+
+const inviteOptions: SIP.InviteOptions = { 
+    media: { 
+        constraints: { audio: true, video: false },
+        stream: new MediaStream(),
+        render: { remote: new Element(), local: new Element() },
+    },
+    anonymous: true,
+    rel100: "",
+    inviteWithoutSdp: true,
+    RTCConstraints: new RTCPeerConnection()
+}
+
+session = ua.invite("", inviteOptions);
+
+ua.on('connected', (args: SIP.UA.EventArgs.ConnectedArgs) => {});
+ua.on('disconnected', () => {});
+ua.on('registered', () => {});
+ua.on('unregistered', (args: SIP.UA.EventArgs.UnregisteredArgs) => {});
+ua.on('registrationFailed', (args: SIP.UA.EventArgs.RegistrationFailedArgs) => {});
+ua.on('invite', (session: SIP.Session) => {
+    session.on('progress', (response) => {
+    });
+    session.on('accepted', (response) => {
+    });
+    session.on('rejected', (response) => {
+    });
+
+});
+ua.on('message', (message: SIP.Message) => {});
diff --git a/SIP.js/index.d.ts b/SIP.js/index.d.ts
new file mode 100644
index 0000000000..0eaabb9b48
--- /dev/null
+++ b/SIP.js/index.d.ts
@@ -0,0 +1,354 @@
+// Type definitions for SIP.js v0.7.6
+// Project: https://sipjs.com/
+// Definitions by: Kir Dergachev <https://github.com/decyrus/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = SIP;
+
+declare namespace SIP {
+
+    class URI {
+        constructor(
+            scheme?: string,
+            user?: string,
+            host?: string,
+            port?: number,
+            parameters?: string[],
+            headers?: string[]);
+
+        scheme?: string;
+        user?: string;
+        host?: string;
+        port?: number;
+
+        setParam(key: string, value?: string): void;
+        getParam(key: string): string;
+        hasParam(key: string): string;
+        deleteParam(key: string): string;
+        clearParams(): void;
+        setHeader(name: string, value: string): void;
+        getHeader(name: string): string[];
+        hasHeader(name: string): boolean;
+        deleteHeader(name: string): string[];
+        clearHeaders(): void;
+        clone(): URI;
+        toString(): string;
+
+        static parse(uri: string): URI;
+    }
+
+    namespace UA.EventArgs {
+        interface ConnectedArgs { attempts: number }
+        interface UnregisteredArgs { response: string; cause: string; }
+        interface RegistrationFailedArgs extends UnregisteredArgs { }
+    }
+
+    class UA {
+        constructor(configuration?: ConfigurationParameters);
+        start(): void;
+        stop(): void;
+        register(options?: ExtraHeadersOptions): UA;
+        unregister(options?: UnregisterOptions): void;
+        isRegistered(): boolean;
+        isConnected(): boolean;
+        message(target: string | URI, body: string, options?: MessageOptions): Message;
+        subscribe(target: string | URI, event: string, options?: SubscribeOptions): Subscription;
+        invite(target: string | URI, options?: InviteOptions): Session;
+        invite(target: string | URI, element?: HTMLAudioElement | HTMLVideoElement): Session;
+        request(method: string, target: string | URI, options?: RequestOptions): ClientContext;
+
+        on(name: 'connected', callback: (args: UA.EventArgs.ConnectedArgs) => void): void;
+        on(name: 'disconnected' | 'registered', callback: () => void): void;
+        on(name: 'unregistered', callback: (args: UA.EventArgs.UnregisteredArgs) => void): void;
+        on(name: 'registrationFailed', callback: (args: UA.EventArgs.RegistrationFailedArgs) => void): void;
+        on(name: 'invite', callback: (session: Session) => void): void;
+        on(name: 'message', callback: (message: Message) => void): void;
+    }
+
+    namespace UA.C {
+        class supported {
+            REQUIRED: string;
+            SUPPORTED: string;
+            UNSUPPORTED: string;
+        }
+
+        class causes {
+            INVALID_TARGET: string;
+            CONNECTION_ERROR: string;
+            REQUEST_TIMEOUT: string;
+            SIP_FAILURE_CODE: string;
+        }
+    }
+
+    class Session {
+        startTime?: Date;
+        endTime?: Date;
+        ua?: UA;
+        method?: string;
+        mediaHandler?: WebRTC.MediaHandler;
+        request?: IncomingRequest | OutgoingRequest;
+        localIdentity?: NameAddrHeader;
+        remoteIdentity?: NameAddrHeader;
+        data: ClientContext | ServerContext;
+
+        dtmf(tone: string | number, options?: Session.DtmfOptions): Session;
+        terminate(options?: Session.CommonOptions): Session;
+        bye(options?: Session.CommonOptions): Session;
+        getLocalStreams(): MediaStream[];
+        getRemoteStreams(): MediaStream[];
+        refer(target: string | Session, options?: ExtraHeadersOptions): Session;
+        mute(options?: ExtraHeadersOptions): void;
+        unmute(options?: ExtraHeadersOptions): void;
+        cancel(options?: Session.CommonOptions): void;
+        progress(options?: Session.ProgressOptions): void;
+        accept(options?: Session.AcceptOptions): void;
+        reject(options?: Session.CommonOptions): void;
+        reply(options?: Session.CommonOptions): void;
+        followRefer(callback: Function): void;
+
+        on(name: 'progress', callback: (response: IncomingResponse) => void): void;
+        on(name: 'accepted', callback: (data: { code: number, response: IncomingResponse }) => void): void;
+        on(name: 'rejected', callback: (response: IncomingResponse, cause: string) => void): void;
+        on(name: 'failed', callback: (response: IncomingResponse, cause: string) => void): void;
+        on(name: 'terminated', callback: (message: IncomingResponse, cause: string) => void): void;
+        on(name: 'refer', callback: (request: IncomingRequest) => void): void;
+        on(name: 'cancel', callback: () => void): void;
+        on(name: 'replaced', callback: (newSession: Session) => void): void;
+        on(name: 'dtmf', callback: (request: IncomingRequest, dtmf: Session.DTMF) => void): void;
+        on(name: 'muted', callback: (data: Session.Muted) => void): void;
+        on(name: 'unmuted', callback: (data: Session.Muted) => void): void;
+        on(name: 'bye', callback: (request: IncomingRequest) => void): void;
+    }
+
+    namespace Session {
+        interface DtmfOptions extends ExtraHeadersOptions {
+            duration?: number;
+            interToneGap?: number;
+        }
+
+        interface CommonOptions extends ExtraHeadersOptions {
+            status_code?: number;
+            reason_phrase?: string;
+            body?: string;
+        }
+
+        interface ProgressOptions extends ExtraHeadersOptions {
+            rel100?: boolean;
+            media?: MediaConstraints;
+        }
+
+        interface AcceptOptions {
+            RTCConstraints?: RTCPeerConnection;
+            media?: MediaOptions;
+        }
+
+        interface DTMF {
+        }
+
+        interface Muted {
+            audio?: boolean;
+            video?: boolean
+        }
+    }
+
+    interface RenderHint {
+        remote?: Element;
+        local?: Element
+    }
+
+    interface MediaConstraints {
+        audio: boolean;
+        video: boolean;
+    }
+
+    interface TurnServer {
+        urls?: string | string[];
+        username?: string;
+        password?: string;
+    }
+
+    namespace WebRTC {
+
+        interface Options {
+            stunServers?: string | string[];
+            turnServers?: TurnServer | TurnServer[];
+            RTCConstraints?: RTCPeerConnection;
+        }
+
+        type MediaHandlerFactory = (session: Session, options: Options) => MediaHandler;
+
+        class MediaHandler {
+            getLocalStreams(): MediaStream[];
+            getRemoteStreams(): MediaStream[];
+            render(renderHint: RenderHint): void;
+
+            on(name: 'userMediaRequest', callback: (constraints: MediaConstraints) => void): void;
+            on(name: 'userMedia', callback: (stream: MediaStream) => void): void;
+            on(name: 'userMediaFailed', callback: (error: string) => void): void;
+            on(name: 'iceGathering', callback: () => void): void;
+            on(name: 'iceCandidate', callback: (candidate: RTCIceCandidate) => void): void;
+            on(name: 'iceGatheringComplete', callback: () => void): void;
+            on(name: 'iceConnection', callback: () => void): void;
+            on(name: 'iceConnectionChecking', callback: () => void): void;
+            on(name: 'iceConnectionConnected', callback: () => void): void;
+            on(name: 'iceConnectionCompleted', callback: () => void): void;
+            on(name: 'iceConnectionFailed', callback: () => void): void;
+            on(name: 'iceConnectionDisconnected', callback: () => void): void;
+            on(name: 'iceConnectionClosed', callback: () => void): void;
+            on(name: 'getDescription', callback: (sdpWrapper: { type: string, sdp: string }) => void): void;
+            on(name: 'setDescription', callback: (sdpWrapper: { type: string, sdp: string }) => void): void;
+            on(name: 'dataChannel', callback: () => void): void;
+            on(name: 'addStream', callback: (stream: MediaStream) => void): void;
+        }
+    }
+
+    /* Parameters */
+    interface ConfigurationParameters {
+        uri?: string;
+        wsServers?: string | string[] | { ws_uri: string; weigth: number }[];
+        allowLegacyNotifications?: boolean;
+        authenticationFactory?: WebRTC.MediaHandlerFactory;
+        authorizationUser?: string;
+        autostart?: boolean;
+        connectionRecoveryMaxInterval?: number;
+        connectionRecoveryMinInterval?: number;
+        displayName?: string;
+        hackCleanJitsiSdpImageattr?: boolean;
+        hackStripTcp?: boolean;
+        hackIpInContact?: boolean;
+        hackViaTcp?: boolean;
+        hackWssInTransport?: boolean;
+        iceCheckingTimeout?: number;
+        instanceId?: string;
+        log?: {
+            builtinEnabled?: boolean;
+            level?: number | string;
+            connector?: (level: string, category: string, label: string, content: string) => void;
+        };
+        mediaHandlerFactory?: WebRTC.MediaHandlerFactory;
+        noAnswerTimeout?: number;
+        password?: string;
+        register?: boolean;
+        registerExpires?: number;
+        registrarServer?: string;
+        rel100?: string;
+        replaces?: string;
+        stunServers?: string | string[];
+        traceSip?: boolean;
+        turnServers?: TurnServer | TurnServer[];
+        usePreloadedRoute?: boolean;
+        userAgentString?: string;
+        wsServerMaxReconnection?: number;
+        wsServerReconnectionTimeout?: number;
+    }
+
+    /* Options */
+    interface ExtraHeadersOptions {
+        extraHeaders?: string[];
+    }
+
+    interface UnregisterOptions extends ExtraHeadersOptions {
+        all?: boolean;
+    }
+
+    interface MessageOptions extends ExtraHeadersOptions {
+        contentType?: string;
+    }
+
+    interface SubscribeOptions extends ExtraHeadersOptions {
+        expires?: number;
+    }
+
+    interface MediaOptions {
+        constraints?: MediaConstraints;
+        stream?: MediaStream;
+        render?: RenderHint;
+    }
+
+    interface InviteOptions extends ExtraHeadersOptions {
+        media?: MediaOptions;
+        anonymous?: boolean;
+        rel100?: string;
+        inviteWithoutSdp?: boolean;
+        RTCConstraints?: RTCPeerConnection;
+    }
+
+    interface RequestOptions extends ExtraHeadersOptions {
+        body?: string;
+    }
+
+    /* Contexts */
+    interface Message extends ClientContext {
+        body: string;
+    }
+
+    interface Subscription extends ClientContext {
+        id: string;
+        state: string;
+        event: string;
+        dialog: string;
+        timers: Object;
+        errorCodes: number[];
+        subscribe(): Subscription;
+        unsubscribe(): void;
+        close(): void;
+    }
+
+    /* Context */
+    interface Context {
+        ua: UA;
+        method: string;
+        request: OutgoingRequest;
+        localIdentity: NameAddrHeader;
+        remoteIdentity: NameAddrHeader;
+        data: {};
+        
+        on(name: 'progress', callback: (response: IncomingMessage, cause: string) => void): void;
+        on(name: 'accepted', callback: (response: IncomingMessage, cause: string) => void): void;
+        on(name: 'rejected', callback: (response: IncomingMessage, cause: string) => void): void;
+        on(name: 'failed', callback: (response: IncomingMessage, cause: string) => void): void;
+        on(name: 'notify', callback: (request: IncomingRequest) => void): void;
+    }
+
+    interface ClientContext extends Context {
+        cancel(options?: { status_code?: number, reason_phrase?: string }): ClientContext;
+    }
+
+    interface ServerContext extends Context {
+        progress(options?: Session.ProgressOptions): void;
+        accept(options?: Session.AcceptOptions): void;
+        reject(options?: Session.CommonOptions): void;
+        reply(options?: Session.CommonOptions): void;
+    }
+
+    /* Request */
+    interface Request extends Context {
+    }
+
+    interface IncomingRequest extends Request {
+    }
+
+    interface OutgoingRequest extends Request {
+    }
+
+    interface IncomingResponse extends Request {
+    }
+
+    interface IncomingMessage extends Request {
+    }
+
+    /* Header */
+    class NameAddrHeader {
+        constructor(uri: string | URI, displayName: string, parameters: { key: string, value: string }[]);
+
+        uri: string | URI;
+        displayName: string;
+
+        setParam(key: string, value?: string): void;
+        getParam(key: string): string;
+        deleteParam(key: string): string;
+        clearParams(): void;
+
+        static parse(name_addr_header: string): NameAddrHeader;
+    }
+}
diff --git a/SIP.js/tsconfig.json b/SIP.js/tsconfig.json
new file mode 100644
index 0000000000..93cce57ffb
--- /dev/null
+++ b/SIP.js/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": ["webrtc"],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "SIP.js-tests.ts"
+    ]
+}
diff --git a/SIP.js/tslint.json b/SIP.js/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/SIP.js/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 3de4a245bdc0dab48b91b51c3937391d04ef2902 Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Fri, 20 Jan 2017 12:14:28 +0300
Subject: [PATCH 11/87] Fixed package case

---
 {SIP.js => sip.js}/index.d.ts                    | 0
 SIP.js/SIP.js-tests.ts => sip.js/sip.js-tests.ts | 0
 {SIP.js => sip.js}/tsconfig.json                 | 2 +-
 {SIP.js => sip.js}/tslint.json                   | 0
 4 files changed, 1 insertion(+), 1 deletion(-)
 rename {SIP.js => sip.js}/index.d.ts (100%)
 rename SIP.js/SIP.js-tests.ts => sip.js/sip.js-tests.ts (100%)
 rename {SIP.js => sip.js}/tsconfig.json (94%)
 rename {SIP.js => sip.js}/tslint.json (100%)

diff --git a/SIP.js/index.d.ts b/sip.js/index.d.ts
similarity index 100%
rename from SIP.js/index.d.ts
rename to sip.js/index.d.ts
diff --git a/SIP.js/SIP.js-tests.ts b/sip.js/sip.js-tests.ts
similarity index 100%
rename from SIP.js/SIP.js-tests.ts
rename to sip.js/sip.js-tests.ts
diff --git a/SIP.js/tsconfig.json b/sip.js/tsconfig.json
similarity index 94%
rename from SIP.js/tsconfig.json
rename to sip.js/tsconfig.json
index 93cce57ffb..8c84c6273e 100644
--- a/SIP.js/tsconfig.json
+++ b/sip.js/tsconfig.json
@@ -18,6 +18,6 @@
     },
     "files": [
         "index.d.ts",
-        "SIP.js-tests.ts"
+        "sip.js-tests.ts"
     ]
 }
diff --git a/SIP.js/tslint.json b/sip.js/tslint.json
similarity index 100%
rename from SIP.js/tslint.json
rename to sip.js/tslint.json

From f0f803116b25f321fca2755a4e6c96129e6c4a7a Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Fri, 20 Jan 2017 12:52:59 +0300
Subject: [PATCH 12/87] Move references from tsconfig

---
 sip.js/index.d.ts    | 2 ++
 sip.js/tsconfig.json | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/sip.js/index.d.ts b/sip.js/index.d.ts
index 0eaabb9b48..3af04495c9 100644
--- a/sip.js/index.d.ts
+++ b/sip.js/index.d.ts
@@ -3,6 +3,8 @@
 // Definitions by: Kir Dergachev <https://github.com/decyrus/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+/// <reference types="webrtc" />
+
 export = SIP;
 
 declare namespace SIP {
diff --git a/sip.js/tsconfig.json b/sip.js/tsconfig.json
index 8c84c6273e..b6532e5674 100644
--- a/sip.js/tsconfig.json
+++ b/sip.js/tsconfig.json
@@ -12,7 +12,7 @@
         "typeRoots": [
             "../"
         ],
-        "types": ["webrtc"],
+        "types": [],
         "noEmit": true,
         "forceConsistentCasingInFileNames": true
     },

From cb6ec66ca995549337896b3e38dc79a097b50c08 Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Fri, 20 Jan 2017 13:22:30 +0300
Subject: [PATCH 13/87] Fix lint error

---
 sip.js/index.d.ts  | 48 ++++++++++++++--------------------------------
 sip.js/tslint.json |  7 ++++++-
 2 files changed, 20 insertions(+), 35 deletions(-)

diff --git a/sip.js/index.d.ts b/sip.js/index.d.ts
index 3af04495c9..8c7a297613 100644
--- a/sip.js/index.d.ts
+++ b/sip.js/index.d.ts
@@ -40,7 +40,7 @@ declare namespace SIP {
     }
 
     namespace UA.EventArgs {
-        interface ConnectedArgs { attempts: number }
+        interface ConnectedArgs { attempts: number; }
         interface UnregisteredArgs { response: string; cause: string; }
         interface RegistrationFailedArgs extends UnregisteredArgs { }
     }
@@ -55,8 +55,7 @@ declare namespace SIP {
         isConnected(): boolean;
         message(target: string | URI, body: string, options?: MessageOptions): Message;
         subscribe(target: string | URI, event: string, options?: SubscribeOptions): Subscription;
-        invite(target: string | URI, options?: InviteOptions): Session;
-        invite(target: string | URI, element?: HTMLAudioElement | HTMLVideoElement): Session;
+        invite(target: string | URI, element?: InviteOptions | HTMLAudioElement | HTMLVideoElement): Session;
         request(method: string, target: string | URI, options?: RequestOptions): ClientContext;
 
         on(name: 'connected', callback: (args: UA.EventArgs.ConnectedArgs) => void): void;
@@ -110,16 +109,13 @@ declare namespace SIP {
 
         on(name: 'progress', callback: (response: IncomingResponse) => void): void;
         on(name: 'accepted', callback: (data: { code: number, response: IncomingResponse }) => void): void;
-        on(name: 'rejected', callback: (response: IncomingResponse, cause: string) => void): void;
-        on(name: 'failed', callback: (response: IncomingResponse, cause: string) => void): void;
+        on(name: 'failed' | 'rejected', callback: (response: IncomingResponse, cause: string) => void): void;
         on(name: 'terminated', callback: (message: IncomingResponse, cause: string) => void): void;
-        on(name: 'refer', callback: (request: IncomingRequest) => void): void;
         on(name: 'cancel', callback: () => void): void;
         on(name: 'replaced', callback: (newSession: Session) => void): void;
         on(name: 'dtmf', callback: (request: IncomingRequest, dtmf: Session.DTMF) => void): void;
-        on(name: 'muted', callback: (data: Session.Muted) => void): void;
-        on(name: 'unmuted', callback: (data: Session.Muted) => void): void;
-        on(name: 'bye', callback: (request: IncomingRequest) => void): void;
+        on(name: 'muted' | 'unmuted', callback: (data: Session.Muted) => void): void;
+        on(name: 'refer' | 'bye', callback: (request: IncomingRequest) => void): void;
     }
 
     namespace Session {
@@ -144,18 +140,17 @@ declare namespace SIP {
             media?: MediaOptions;
         }
 
-        interface DTMF {
-        }
+        interface DTMF extends Object {}
 
         interface Muted {
             audio?: boolean;
-            video?: boolean
+            video?: boolean;
         }
     }
 
     interface RenderHint {
         remote?: Element;
-        local?: Element
+        local?: Element;
     }
 
     interface MediaConstraints {
@@ -185,29 +180,18 @@ declare namespace SIP {
             render(renderHint: RenderHint): void;
 
             on(name: 'userMediaRequest', callback: (constraints: MediaConstraints) => void): void;
-            on(name: 'userMedia', callback: (stream: MediaStream) => void): void;
+            on(name: 'addStream' | 'userMedia', callback: (stream: MediaStream) => void): void;
             on(name: 'userMediaFailed', callback: (error: string) => void): void;
-            on(name: 'iceGathering', callback: () => void): void;
             on(name: 'iceCandidate', callback: (candidate: RTCIceCandidate) => void): void;
-            on(name: 'iceGatheringComplete', callback: () => void): void;
-            on(name: 'iceConnection', callback: () => void): void;
-            on(name: 'iceConnectionChecking', callback: () => void): void;
-            on(name: 'iceConnectionConnected', callback: () => void): void;
-            on(name: 'iceConnectionCompleted', callback: () => void): void;
-            on(name: 'iceConnectionFailed', callback: () => void): void;
-            on(name: 'iceConnectionDisconnected', callback: () => void): void;
-            on(name: 'iceConnectionClosed', callback: () => void): void;
-            on(name: 'getDescription', callback: (sdpWrapper: { type: string, sdp: string }) => void): void;
-            on(name: 'setDescription', callback: (sdpWrapper: { type: string, sdp: string }) => void): void;
-            on(name: 'dataChannel', callback: () => void): void;
-            on(name: 'addStream', callback: (stream: MediaStream) => void): void;
+            on(name: 'iceGathering' | 'iceGatheringComplete' | 'iceConnection' | 'iceConnectionChecking' | 'iceConnectionConnected' | 'iceConnectionCompleted' | 'iceConnectionFailed' | 'iceConnectionDisconnected' | 'iceConnectionClosed', callback: () => void): void;
+            on(name: 'dataChannel' | 'getDescription' | 'setDescription', callback: (sdpWrapper: { type: string, sdp: string }) => void): void;
         }
     }
 
     /* Parameters */
     interface ConfigurationParameters {
         uri?: string;
-        wsServers?: string | string[] | { ws_uri: string; weigth: number }[];
+        wsServers?: string | string[] | Array<{ ws_uri: string; weigth: number }>;
         allowLegacyNotifications?: boolean;
         authenticationFactory?: WebRTC.MediaHandlerFactory;
         authorizationUser?: string;
@@ -304,11 +288,7 @@ declare namespace SIP {
         localIdentity: NameAddrHeader;
         remoteIdentity: NameAddrHeader;
         data: {};
-        
-        on(name: 'progress', callback: (response: IncomingMessage, cause: string) => void): void;
-        on(name: 'accepted', callback: (response: IncomingMessage, cause: string) => void): void;
-        on(name: 'rejected', callback: (response: IncomingMessage, cause: string) => void): void;
-        on(name: 'failed', callback: (response: IncomingMessage, cause: string) => void): void;
+        on(name: 'progress' | 'accepted' | 'rejected' | 'failed', callback: (response: IncomingMessage, cause: string) => void): void;
         on(name: 'notify', callback: (request: IncomingRequest) => void): void;
     }
 
@@ -341,7 +321,7 @@ declare namespace SIP {
 
     /* Header */
     class NameAddrHeader {
-        constructor(uri: string | URI, displayName: string, parameters: { key: string, value: string }[]);
+        constructor(uri: string | URI, displayName: string, parameters: Array<{ key: string, value: string }>);
 
         uri: string | URI;
         displayName: string;
diff --git a/sip.js/tslint.json b/sip.js/tslint.json
index 377cc837d4..105f5736e6 100644
--- a/sip.js/tslint.json
+++ b/sip.js/tslint.json
@@ -1 +1,6 @@
-{ "extends": "../tslint.json" }
+{
+    "extends": "../tslint.json",
+    "rules": {
+        "no-empty-interface": false
+    }
+}

From 2cc1c6e25dc4fd757dc98503f985678ebf4a21ef Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Fri, 20 Jan 2017 13:58:52 +0300
Subject: [PATCH 14/87] Fix type definition test errors

---
 sip.js/index.d.ts | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/sip.js/index.d.ts b/sip.js/index.d.ts
index 8c7a297613..a8d2b3c8db 100644
--- a/sip.js/index.d.ts
+++ b/sip.js/index.d.ts
@@ -1,13 +1,11 @@
-// Type definitions for SIP.js v0.7.6
+// Type definitions for SIP.js 0.7
 // Project: https://sipjs.com/
 // Definitions by: Kir Dergachev <https://github.com/decyrus/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="webrtc" />
 
-export = SIP;
-
-declare namespace SIP {
+export declare namespace SIP {
 
     class URI {
         constructor(
@@ -105,7 +103,7 @@ declare namespace SIP {
         accept(options?: Session.AcceptOptions): void;
         reject(options?: Session.CommonOptions): void;
         reply(options?: Session.CommonOptions): void;
-        followRefer(callback: Function): void;
+        followRefer(callback: () => void): void;
 
         on(name: 'progress', callback: (response: IncomingResponse) => void): void;
         on(name: 'accepted', callback: (data: { code: number, response: IncomingResponse }) => void): void;
@@ -273,7 +271,7 @@ declare namespace SIP {
         state: string;
         event: string;
         dialog: string;
-        timers: Object;
+        timers: {};
         errorCodes: number[];
         subscribe(): Subscription;
         unsubscribe(): void;

From 1c753b2c69e2df6a45a06cdfa2568a30f7d655ba Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Fri, 20 Jan 2017 14:40:08 +0300
Subject: [PATCH 15/87] Fix tslint errors, configure rules

---
 sip.js/index.d.ts  | 10 ++++++----
 sip.js/tslint.json |  3 ++-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/sip.js/index.d.ts b/sip.js/index.d.ts
index a8d2b3c8db..942a0d22b3 100644
--- a/sip.js/index.d.ts
+++ b/sip.js/index.d.ts
@@ -1,11 +1,13 @@
-// Type definitions for SIP.js 0.7
-// Project: https://sipjs.com/
-// Definitions by: Kir Dergachev <https://github.com/decyrus/>
+// Type definitions for sip.js 0.7
+// Project: http://sipjs.com
+// Definitions by: Kir Dergachev <https://github.com/decyrus>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="webrtc" />
 
-export declare namespace SIP {
+export = SIP;
+
+declare namespace SIP {
 
     class URI {
         constructor(
diff --git a/sip.js/tslint.json b/sip.js/tslint.json
index 105f5736e6..c78c443ad2 100644
--- a/sip.js/tslint.json
+++ b/sip.js/tslint.json
@@ -1,6 +1,7 @@
 {
     "extends": "../tslint.json",
     "rules": {
-        "no-empty-interface": false
+        "no-empty-interface": false,
+        "export-just-namespace": false
     }
 }

From d2be90a50693461d0e2e4dd20c3d578533a779db Mon Sep 17 00:00:00 2001
From: mkollers <mkollers@users.noreply.github.com>
Date: Mon, 23 Jan 2017 10:26:59 +0100
Subject: [PATCH 16/87] added group to Node

http://visjs.org/docs/network/nodes.html#
---
 vis/index.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/vis/index.d.ts b/vis/index.d.ts
index 92b6ea6a08..3ee00ba03a 100644
--- a/vis/index.d.ts
+++ b/vis/index.d.ts
@@ -1497,6 +1497,7 @@ export interface Data {
 }
 
 export interface Node {
+  group?: string;
   id?: IdType;
   label?: string;
   x?: number;

From 39772baa2c32da872c8482088c784eb497e303c0 Mon Sep 17 00:00:00 2001
From: SamSchelfhout <sam@schelfhout.net>
Date: Mon, 23 Jan 2017 10:37:00 +0100
Subject: [PATCH 17/87] Update index.d.ts to support ajaxTransport

Update index.d.ts to jQuery.ajaxTransport().
See https://api.jquery.com/jQuery.ajaxTransport/
---
 jquery/index.d.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/jquery/index.d.ts b/jquery/index.d.ts
index e0bf072983..3a785530aa 100644
--- a/jquery/index.d.ts
+++ b/jquery/index.d.ts
@@ -786,6 +786,15 @@ interface JQueryStatic {
      */
     ajaxPrefilter(handler: (opts: any, originalOpts: JQueryAjaxSettings, jqXHR: JQueryXHR) => any): void;
 
+     /**
+     * Creates an object that handles the actual transmission of Ajax data.
+     *
+     * @param dataType A string identifying the data type to use.
+     * @param handler A handler to return the new transport object to use with the data type provided in the first argument.
+     * @see {@link https://api.jquery.com/jQuery.ajaxTransport/}
+     */
+    ajaxTransport(dataType: string, handler: (opts: any, originalOpts: JQueryAjaxSettings, jqXHR: JQueryXHR) => any): void;
+    
     ajaxSettings: JQueryAjaxSettings;
 
      /**

From ff113b3b1cfb2b7c98e2efd6e10ddb04d43bc031 Mon Sep 17 00:00:00 2001
From: darlin <duxiaodong@darlin.me>
Date: Mon, 23 Jan 2017 20:14:41 +0800
Subject: [PATCH 18/87] add sub module export

---
 crypto-js/index.d.ts | 237 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 234 insertions(+), 3 deletions(-)

diff --git a/crypto-js/index.d.ts b/crypto-js/index.d.ts
index 5fdf193254..a2c0ee381d 100644
--- a/crypto-js/index.d.ts
+++ b/crypto-js/index.d.ts
@@ -3,9 +3,6 @@
 // Definitions by: Michael Zabka <https://github.com/misak113/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-export = CryptoJS;
-export as namespace CryptoJS;
-
 declare var CryptoJS: CryptoJS.Hashes;
 declare namespace CryptoJS {
 	type Hash = (message: string, key?: string, ...options: any[]) => string;
@@ -113,5 +110,239 @@ declare namespace CryptoJS {
 			NoPadding: Padding;
 		};
 	}
+
 }
 
+declare module "crypto-js" {
+	var CryptoJS: CryptoJS.Hashes;
+	export = CryptoJS;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/core" {
+	var core: any;
+	export = core;
+}
+
+declare module "crypto-js/x64-core" {
+	var x64: any;
+	export = x64;
+}
+
+declare module "crypto-js/lib-typedarrays" {
+	var libWordArray: any;
+	export = libWordArray;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/md5" {
+	var MD5: CryptoJS.Hash;
+	export = MD5;
+}
+
+declare module "crypto-js/sha1" {
+	var SHA1: CryptoJS.Hash;
+	export = SHA1;
+}
+
+declare module "crypto-js/sha256" {
+	var SHA256: CryptoJS.Hash;
+	export = SHA256;
+}
+
+declare module "crypto-js/sha224" {
+	var SHA224: CryptoJS.Hash;
+	export = SHA224;
+}
+
+declare module "crypto-js/sha512" {
+	var SHA512: CryptoJS.Hash;
+	export = SHA512;
+}
+
+declare module "crypto-js/sha384" {
+	var SHA384: CryptoJS.Hash;
+	export = SHA384;
+}
+
+declare module "crypto-js/sha3" {
+	var SHA3: CryptoJS.Hash;
+	export = SHA3;
+}
+
+declare module "crypto-js/ripemd160" {
+	var RIPEMD160: CryptoJS.Hash;
+	export = RIPEMD160;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/hmac-md5" {
+	var HmacMD5: CryptoJS.Hash;
+	export = HmacMD5;
+}
+
+declare module "crypto-js/hmac-sha1" {
+	var HmacSHA1: CryptoJS.Hash;
+	export = HmacSHA1;
+}
+
+declare module "crypto-js/hmac-sha256" {
+	var HmacSHA256: CryptoJS.Hash;
+	export = HmacSHA256;
+}
+
+declare module "crypto-js/hmac-sha224" {
+	var HmacSHA224: CryptoJS.Hash;
+	export = HmacSHA224;
+}
+
+declare module "crypto-js/hmac-sha512" {
+	var HmacSHA512: CryptoJS.Hash;
+	export = HmacSHA512;
+}
+
+declare module "crypto-js/hmac-sha384" {
+	var HmacSHA384: CryptoJS.Hash;
+	export = HmacSHA384;
+}
+
+declare module "crypto-js/hmac-sha3" {
+	var HmacSHA3: CryptoJS.Hash;
+	export = HmacSHA3;
+}
+
+declare module "crypto-js/hmac-ripemd160" {
+	var HmacRIPEMD160: CryptoJS.Hash;
+	export = HmacRIPEMD160;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/pbkdf2" {
+	var PBKDF2: CryptoJS.Hash;
+	export = PBKDF2;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/aes" {
+	var AES: CryptoJS.Cipher;
+	export = AES;
+}
+
+declare module "crypto-js/tripledes" {
+	var TripleDES: CryptoJS.Cipher;
+	export = TripleDES;
+}
+
+declare module "crypto-js/rc4" {
+	var RC4: CryptoJS.Cipher;
+	export = RC4;
+}
+
+declare module "crypto-js/rabbit" {
+	var Rabbit: CryptoJS.Cipher;
+	export = Rabbit;
+}
+
+declare module "crypto-js/rabbit-legacy" {
+	var RabbitLegacy: CryptoJS.Cipher;
+	export = RabbitLegacy;
+}
+
+declare module "crypto-js/evpkdf" {
+	var EvpKDF: CryptoJS.Cipher;
+	export = EvpKDF;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/format-openssl" {
+	var FormatOpenssl: any;
+	export = FormatOpenssl;
+}
+
+declare module "crypto-js/format-hex" {
+	var FormatHex: any;
+	export = FormatHex;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/enc-latin1" {
+	var encLatin1: CryptoJS.Encoder;
+	export = encLatin1;
+}
+
+declare module "crypto-js/enc-utf8" {
+	var encUtf8: CryptoJS.Encoder;
+	export = encUtf8;
+}
+
+declare module "crypto-js/enc-hex" {
+	var encHex: CryptoJS.Encoder;
+	export = encHex;
+}
+
+declare module "crypto-js/enc-utf16" {
+	var encUtf16: CryptoJS.Encoder;
+	export = encUtf16;
+}
+
+declare module "crypto-js/enc-base64" {
+	var encBase64: CryptoJS.Encoder;
+	export = encBase64;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/mode-cfb" {
+	var modeCFB: CryptoJS.Mode;
+	export = modeCFB;
+}
+
+declare module "crypto-js/mode-ctr" {
+	var modeCTR: CryptoJS.Mode;
+	export = modeCTR;
+}
+
+declare module "crypto-js/mode-ctr-gladman" {
+	var modeCTRGladman: CryptoJS.Mode;
+	export = modeCTRGladman;
+}
+
+declare module "crypto-js/mode-ofb" {
+	var modeOFB: CryptoJS.Mode;
+	export = modeOFB;
+}
+
+declare module "crypto-js/mode-ecb" {
+	var modeECB: CryptoJS.Mode;
+	export = modeECB;
+}
+
+/* --------------------------------- */
+declare module "crypto-js/pad-pkcs7" {
+	var padPkcs7: CryptoJS.Padding;
+	export = padPkcs7;
+}
+
+declare module "crypto-js/pad-ansix923" {
+	var padAnsiX923: CryptoJS.Padding;
+	export = padAnsiX923;
+}
+
+declare module "crypto-js/pad-iso10126" {
+	var padIso10126: CryptoJS.Padding;
+	export = padIso10126;
+}
+
+declare module "crypto-js/pad-iso97971" {
+	var padIso97971: CryptoJS.Padding;
+	export = padIso97971;
+}
+
+declare module "crypto-js/pad-zeropadding" {
+	var padZeroPadding: CryptoJS.Padding;
+	export = padZeroPadding;
+}
+
+declare module "crypto-js/pad-nopadding" {
+	var padNoPadding: CryptoJS.Padding;
+	export = padNoPadding;
+}

From 7ba0fa586127729532dbe3aad56f6547385745fd Mon Sep 17 00:00:00 2001
From: darlin <duxiaodong@darlin.me>
Date: Mon, 23 Jan 2017 20:35:35 +0800
Subject: [PATCH 19/87] add typescript module export to suport import * as
 SimpleMDE from 'simplemde'

---
 simplemde/index.d.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/simplemde/index.d.ts b/simplemde/index.d.ts
index 6c199f48a7..eb463ae655 100644
--- a/simplemde/index.d.ts
+++ b/simplemde/index.d.ts
@@ -127,4 +127,8 @@ declare class SimpleMDE {
     static toggleFullScreen: (editor: SimpleMDE) => void;
     static undo: (editor: SimpleMDE) => void;
     static redo: (editor: SimpleMDE) => void;
-}
\ No newline at end of file
+}
+
+declare module "simplemde" {
+    export = SimpleMDE;
+}

From fc6a9729df46769b7a50cffe4414dc913ba6da28 Mon Sep 17 00:00:00 2001
From: Kir Dergachev <k.dergachev@h-h-i.ru>
Date: Mon, 23 Jan 2017 16:14:33 +0300
Subject: [PATCH 20/87] Fixes errors references. Removes references to webrtc

---
 sip.js/index.d.ts      | 68 ++++++++++++++++++++----------------------
 sip.js/sip.js-tests.ts | 36 +++++++++++-----------
 sip.js/tslint.json     |  3 +-
 3 files changed, 51 insertions(+), 56 deletions(-)

diff --git a/sip.js/index.d.ts b/sip.js/index.d.ts
index 942a0d22b3..be01cd3682 100644
--- a/sip.js/index.d.ts
+++ b/sip.js/index.d.ts
@@ -3,21 +3,23 @@
 // Definitions by: Kir Dergachev <https://github.com/decyrus>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="webrtc" />
+declare interface SIP {
+    UA: {
+        new (configuration?: sipjs.ConfigurationParameters): sipjs.UA;
+    };
+    URI: {
+        new (scheme?: string, user?: string, host?: string, port?: number, parameters?: string[], headers?: string[]): sipjs.URI;
+        parse(uri: string): sipjs.URI;
+    };
+    NameAddrHeader: {
+        new (uri: string | sipjs.URI, displayName: string, parameters: Array<{ key: string, value: string }>): sipjs.NameAddrHeader;
+        parse(name_addr_header: string): sipjs.NameAddrHeader;
+    };
+}
 
-export = SIP;
-
-declare namespace SIP {
-
-    class URI {
-        constructor(
-            scheme?: string,
-            user?: string,
-            host?: string,
-            port?: number,
-            parameters?: string[],
-            headers?: string[]);
+declare namespace sipjs {
 
+    interface URI {
         scheme?: string;
         user?: string;
         host?: string;
@@ -35,8 +37,6 @@ declare namespace SIP {
         clearHeaders(): void;
         clone(): URI;
         toString(): string;
-
-        static parse(uri: string): URI;
     }
 
     namespace UA.EventArgs {
@@ -45,8 +45,7 @@ declare namespace SIP {
         interface RegistrationFailedArgs extends UnregisteredArgs { }
     }
 
-    class UA {
-        constructor(configuration?: ConfigurationParameters);
+    interface UA {
         start(): void;
         stop(): void;
         register(options?: ExtraHeadersOptions): UA;
@@ -59,7 +58,7 @@ declare namespace SIP {
         request(method: string, target: string | URI, options?: RequestOptions): ClientContext;
 
         on(name: 'connected', callback: (args: UA.EventArgs.ConnectedArgs) => void): void;
-        on(name: 'disconnected' | 'registered', callback: () => void): void;
+        on(name: 'disconnected' | 'registered' | string, callback: () => void): void;
         on(name: 'unregistered', callback: (args: UA.EventArgs.UnregisteredArgs) => void): void;
         on(name: 'registrationFailed', callback: (args: UA.EventArgs.RegistrationFailedArgs) => void): void;
         on(name: 'invite', callback: (session: Session) => void): void;
@@ -81,7 +80,7 @@ declare namespace SIP {
         }
     }
 
-    class Session {
+    interface Session {
         startTime?: Date;
         endTime?: Date;
         ua?: UA;
@@ -95,8 +94,8 @@ declare namespace SIP {
         dtmf(tone: string | number, options?: Session.DtmfOptions): Session;
         terminate(options?: Session.CommonOptions): Session;
         bye(options?: Session.CommonOptions): Session;
-        getLocalStreams(): MediaStream[];
-        getRemoteStreams(): MediaStream[];
+        getLocalStreams(): any[];
+        getRemoteStreams(): any[];
         refer(target: string | Session, options?: ExtraHeadersOptions): Session;
         mute(options?: ExtraHeadersOptions): void;
         unmute(options?: ExtraHeadersOptions): void;
@@ -111,7 +110,7 @@ declare namespace SIP {
         on(name: 'accepted', callback: (data: { code: number, response: IncomingResponse }) => void): void;
         on(name: 'failed' | 'rejected', callback: (response: IncomingResponse, cause: string) => void): void;
         on(name: 'terminated', callback: (message: IncomingResponse, cause: string) => void): void;
-        on(name: 'cancel', callback: () => void): void;
+        on(name: 'cancel' | string, callback: () => void): void;
         on(name: 'replaced', callback: (newSession: Session) => void): void;
         on(name: 'dtmf', callback: (request: IncomingRequest, dtmf: Session.DTMF) => void): void;
         on(name: 'muted' | 'unmuted', callback: (data: Session.Muted) => void): void;
@@ -136,7 +135,7 @@ declare namespace SIP {
         }
 
         interface AcceptOptions {
-            RTCConstraints?: RTCPeerConnection;
+            RTCConstraints?: any;
             media?: MediaOptions;
         }
 
@@ -169,21 +168,21 @@ declare namespace SIP {
         interface Options {
             stunServers?: string | string[];
             turnServers?: TurnServer | TurnServer[];
-            RTCConstraints?: RTCPeerConnection;
+            RTCConstraints?: any;
         }
 
         type MediaHandlerFactory = (session: Session, options: Options) => MediaHandler;
 
         class MediaHandler {
-            getLocalStreams(): MediaStream[];
-            getRemoteStreams(): MediaStream[];
+            getLocalStreams(): any[];
+            getRemoteStreams(): any[];
             render(renderHint: RenderHint): void;
 
             on(name: 'userMediaRequest', callback: (constraints: MediaConstraints) => void): void;
-            on(name: 'addStream' | 'userMedia', callback: (stream: MediaStream) => void): void;
+            on(name: 'addStream' | 'userMedia', callback: (stream: any) => void): void;
             on(name: 'userMediaFailed', callback: (error: string) => void): void;
-            on(name: 'iceCandidate', callback: (candidate: RTCIceCandidate) => void): void;
-            on(name: 'iceGathering' | 'iceGatheringComplete' | 'iceConnection' | 'iceConnectionChecking' | 'iceConnectionConnected' | 'iceConnectionCompleted' | 'iceConnectionFailed' | 'iceConnectionDisconnected' | 'iceConnectionClosed', callback: () => void): void;
+            on(name: 'iceCandidate', callback: (candidate: any) => void): void;
+            on(name: 'iceGathering' | 'iceGatheringComplete' | 'iceConnection' | 'iceConnectionChecking' | 'iceConnectionConnected' | 'iceConnectionCompleted' | 'iceConnectionFailed' | 'iceConnectionDisconnected' | 'iceConnectionClosed' | string, callback: () => void): void;
             on(name: 'dataChannel' | 'getDescription' | 'setDescription', callback: (sdpWrapper: { type: string, sdp: string }) => void): void;
         }
     }
@@ -247,7 +246,7 @@ declare namespace SIP {
 
     interface MediaOptions {
         constraints?: MediaConstraints;
-        stream?: MediaStream;
+        stream?: any;
         render?: RenderHint;
     }
 
@@ -256,7 +255,7 @@ declare namespace SIP {
         anonymous?: boolean;
         rel100?: string;
         inviteWithoutSdp?: boolean;
-        RTCConstraints?: RTCPeerConnection;
+        RTCConstraints?: any;
     }
 
     interface RequestOptions extends ExtraHeadersOptions {
@@ -290,6 +289,7 @@ declare namespace SIP {
         data: {};
         on(name: 'progress' | 'accepted' | 'rejected' | 'failed', callback: (response: IncomingMessage, cause: string) => void): void;
         on(name: 'notify', callback: (request: IncomingRequest) => void): void;
+        on(name: string, callback: () => void): void;
     }
 
     interface ClientContext extends Context {
@@ -320,9 +320,7 @@ declare namespace SIP {
     }
 
     /* Header */
-    class NameAddrHeader {
-        constructor(uri: string | URI, displayName: string, parameters: Array<{ key: string, value: string }>);
-
+    interface NameAddrHeader {
         uri: string | URI;
         displayName: string;
 
@@ -330,7 +328,5 @@ declare namespace SIP {
         getParam(key: string): string;
         deleteParam(key: string): string;
         clearParams(): void;
-
-        static parse(name_addr_header: string): NameAddrHeader;
     }
 }
diff --git a/sip.js/sip.js-tests.ts b/sip.js/sip.js-tests.ts
index f688fe67ae..524caf1827 100644
--- a/sip.js/sip.js-tests.ts
+++ b/sip.js/sip.js-tests.ts
@@ -1,11 +1,11 @@
-import SIP = require("./index");
+declare var sip: SIP;
 
-let ua: SIP.UA = new SIP.UA();
+let ua: sipjs.UA = new sip.UA();
 
-const mediaHandler = (session: SIP.Session, options: SIP.WebRTC.Options) => new SIP.WebRTC.MediaHandler();
+const mediaHandler = (session: sipjs.Session, options: sipjs.WebRTC.Options) => new sipjs.WebRTC.MediaHandler();
 const logConnector = (level: string, category: string, label: string, content: string) => null;
 
-const uaWithConfig: SIP.UA = new SIP.UA({
+const uaWithConfig: sipjs.UA = new sip.UA({
     uri: "wss://uri",
     wsServers: ["s1", "s2"],
     allowLegacyNotifications: true,
@@ -38,7 +38,7 @@ const uaWithConfig: SIP.UA = new SIP.UA({
     stunServers: ["", ""],
     turnServers: [
         {
-            password: "", 
+            password: "",
             username: "",
             urls: ["", ""]
         }
@@ -61,15 +61,15 @@ ua.unregister({ extraHeaders: [""], all: true });
 const isConnected: boolean = ua.isConnected();
 const isRegistered: boolean = ua.isRegistered();
 
-const message: SIP.Message = ua.message("", "", { contentType: "" });
+const message: sipjs.Message = ua.message("", "", { contentType: "" });
 
-ua.subscribe("", "", { expires: 1, extraHeaders: [""]});
-const subscription: SIP.Subscription = ua.subscribe(new SIP.URI(), "", { expires: 1, extraHeaders: [""]});
+ua.subscribe("", "", { expires: 1, extraHeaders: [""] });
+const subscription: sipjs.Subscription = ua.subscribe(new sip.URI(), "", { expires: 1, extraHeaders: [""] });
 
 let session = ua.invite("", new HTMLVideoElement());
 
-const inviteOptions: SIP.InviteOptions = { 
-    media: { 
+const inviteOptions: sipjs.InviteOptions = {
+    media: {
         constraints: { audio: true, video: false },
         stream: new MediaStream(),
         render: { remote: new Element(), local: new Element() },
@@ -77,17 +77,17 @@ const inviteOptions: SIP.InviteOptions = {
     anonymous: true,
     rel100: "",
     inviteWithoutSdp: true,
-    RTCConstraints: new RTCPeerConnection()
+    RTCConstraints: {}
 }
 
 session = ua.invite("", inviteOptions);
 
-ua.on('connected', (args: SIP.UA.EventArgs.ConnectedArgs) => {});
-ua.on('disconnected', () => {});
-ua.on('registered', () => {});
-ua.on('unregistered', (args: SIP.UA.EventArgs.UnregisteredArgs) => {});
-ua.on('registrationFailed', (args: SIP.UA.EventArgs.RegistrationFailedArgs) => {});
-ua.on('invite', (session: SIP.Session) => {
+ua.on('connected', (args: sipjs.UA.EventArgs.ConnectedArgs) => { });
+ua.on('disconnected', () => { });
+ua.on('registered', () => { });
+ua.on('unregistered', (args: sipjs.UA.EventArgs.UnregisteredArgs) => { });
+ua.on('registrationFailed', (args: sipjs.UA.EventArgs.RegistrationFailedArgs) => { });
+ua.on('invite', (session: sipjs.Session) => {
     session.on('progress', (response) => {
     });
     session.on('accepted', (response) => {
@@ -96,4 +96,4 @@ ua.on('invite', (session: SIP.Session) => {
     });
 
 });
-ua.on('message', (message: SIP.Message) => {});
+ua.on('message', (message: sipjs.Message) => { });
diff --git a/sip.js/tslint.json b/sip.js/tslint.json
index c78c443ad2..105f5736e6 100644
--- a/sip.js/tslint.json
+++ b/sip.js/tslint.json
@@ -1,7 +1,6 @@
 {
     "extends": "../tslint.json",
     "rules": {
-        "no-empty-interface": false,
-        "export-just-namespace": false
+        "no-empty-interface": false
     }
 }

From 2c380af908a2e6261078153598170b1fd84bd39f Mon Sep 17 00:00:00 2001
From: Sergei Dorogin <sergei@dorogin.com>
Date: Tue, 24 Jan 2017 17:44:31 +0300
Subject: [PATCH 21/87] jquery.fileupload

added `add` callback signature (was `any`)
changed `fail` callback signature (JQueryFileInputOptions => JQueryFileUploadDone)
added JQueryFileUploadXhr.errorThrown field
---
 jquery.fileupload/index.d.ts | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/jquery.fileupload/index.d.ts b/jquery.fileupload/index.d.ts
index 54ebb89c5c..e113d2733c 100644
--- a/jquery.fileupload/index.d.ts
+++ b/jquery.fileupload/index.d.ts
@@ -198,7 +198,7 @@ interface JQueryFileInputOptions {
      * handlers using jQuery's Deferred callbacks:
      * data.submit().done(func).fail(func).always(func);
      */
-    add?: any;
+    add?:  (e: JQueryEventObject, data: JQueryFileInputOptions) => void;
 
     // The plugin options are used as settings object for the ajax calls.
     // The following are jQuery ajax settings required for the file uploads:
@@ -228,7 +228,7 @@ interface JQueryFileInputOptions {
     // Other callbacks:
     submit?: Function;
     done?: (e: JQueryEventObject, data: JQueryFileUploadDone) => void;
-    fail?: (e: JQueryEventObject, data: JQueryFileInputOptions) => void;
+    fail?: (e: JQueryEventObject, data: JQueryFileUploadDone) => void;
     always?: (e: JQueryEventObject, data: JQueryFileInputOptions) => void;
     progressall?: (e: JQueryEventObject, data: JQueryFileUploadProgressAllObject) => void;
     start?: (e: JQueryEventObject) => void;
@@ -284,6 +284,7 @@ interface JQueryFileUploadXhr {
     jqXHR: JQueryXHR;
     result: any;
     textStatus: string;
+    errorThrown: any;
     headers: {[key: string]: any};
 }
 

From 8698554563f4acdf0942ffe9f74b6cce394f9f10 Mon Sep 17 00:00:00 2001
From: darlin <duxiaodong@darlin.me>
Date: Wed, 25 Jan 2017 10:13:32 +0800
Subject: [PATCH 22/87] use appropriate export

---
 simplemde/index.d.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/simplemde/index.d.ts b/simplemde/index.d.ts
index eb463ae655..c78d4fb408 100644
--- a/simplemde/index.d.ts
+++ b/simplemde/index.d.ts
@@ -129,6 +129,5 @@ declare class SimpleMDE {
     static redo: (editor: SimpleMDE) => void;
 }
 
-declare module "simplemde" {
-    export = SimpleMDE;
-}
+export = SimpleMDE;
+export as namespace SimpleMDE;

From a6e94fdb0a80fbeacea1786d60cc0a67deaf9d6b Mon Sep 17 00:00:00 2001
From: Shun <shuntksh@gmail.com>
Date: Tue, 24 Jan 2017 21:54:20 -0800
Subject: [PATCH 23/87] Add module

---
 forever-monitor/forever-monitor-tests.ts |   0
 forever-monitor/index.d.ts               | 104 +++++++++++++++++++++++
 forever-monitor/tsconfig.json            |  20 +++++
 forever-monitor/tslint.json              |   1 +
 4 files changed, 125 insertions(+)
 create mode 100644 forever-monitor/forever-monitor-tests.ts
 create mode 100644 forever-monitor/index.d.ts
 create mode 100644 forever-monitor/tsconfig.json
 create mode 100644 forever-monitor/tslint.json

diff --git a/forever-monitor/forever-monitor-tests.ts b/forever-monitor/forever-monitor-tests.ts
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/forever-monitor/index.d.ts b/forever-monitor/index.d.ts
new file mode 100644
index 0000000000..b22905cae2
--- /dev/null
+++ b/forever-monitor/index.d.ts
@@ -0,0 +1,104 @@
+// Type definitions for forever-monitor 1.7
+// Project: https://github.com/nodejitsu/forever-monitor#readme
+// Definitions by: My Self <https://github.com/me>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+/// <reference types="node" />
+
+interface spawnWith {
+    customFds: number[];
+    setsid: boolean;
+    uid: number;
+    gid: number;
+}
+
+interface parserArgs {
+    command: string;
+    args: string[];
+}
+
+interface Options {
+    silent?: boolean;
+    uid?: "autogen" | string;
+    pidFile?: string;
+    max?: number;
+    killTree?: boolean;
+    minUptime?: number;
+    spinSleepTime?: number;
+    command?: "node" | string;
+    args?: string[];
+    sourceDir?: string;
+    watch?: boolean;
+    watchIgnoreDotFiles?: boolean;
+    watchIgnorePatters?: string[];
+    watchDirectory?: string;
+    spawnWith?: spawnWith;
+    env?: { [envKey: string]: string; };
+    cwd?: string;
+    logFile?: string;
+    outFile?: string;
+    errFile?: string;
+    parser?: (command: string, args: string[]) => { command: string, args: string[] };
+}
+
+
+export declare class Monitor extends NodeJS.EventEmitter {
+
+    /**
+     * @param script - Location of the target script to run.
+     * @param [options] - Configuration for this instance.
+     */
+    constructor(script: string, options?: Options);
+
+    /**
+     * @description Start the process that this instance is configured for
+     * @param [restart] - Value indicating whether this is a restart.
+     */
+    public start(restart?: boolean): this;
+
+    /**
+     * @description Tries to spawn the target Forever child process.
+     */
+    public trySpawn(): boolean;
+
+    /**
+     * @description Restarts the target script associated with this instance.
+     */
+    public restart(): this;
+
+    /**
+     * @description Stops the target script associated with this instance. Prevents it from auto-respawning
+     */
+    public stop(): this;
+
+    /**
+     * @description Kills the ChildProcess object associated with this instance
+     * @param [forceStop] - Value indicating whether short circuit forever auto-restart
+     */
+    public kill(forceStop?: boolean): this;
+
+    /**
+     * @description Sends a message to a forked ChildProcess object associated with this instance
+     */
+    public send(msg?: any): this;
+
+    /**
+     * respond with JSON for this instance
+     */
+    public toString(): string;
+
+    /**
+     * @param command - Command string to parse
+     * @param args - Additional default arguments
+     */
+    public parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
+}
+
+interface forever {
+    Monitor: Monitor;
+    start: (script: string, options: Options) => Monitor;
+    kill: (pid: number, killTree?: boolean, signal?: string, callback?: () => any) => void;
+    checkProcess: (pid: number) => boolean;
+    version: string;
+}
+
+export default forever;
diff --git a/forever-monitor/tsconfig.json b/forever-monitor/tsconfig.json
new file mode 100644
index 0000000000..8c6d4986b5
--- /dev/null
+++ b/forever-monitor/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "forever-monitor-tests.ts"
+    ]
+}
diff --git a/forever-monitor/tslint.json b/forever-monitor/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/forever-monitor/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 1ca0a1b3f98ad5ce8713543791b97014d5250bd6 Mon Sep 17 00:00:00 2001
From: darlin <duxiaodong@darlin.me>
Date: Wed, 25 Jan 2017 14:26:11 +0800
Subject: [PATCH 24/87] update submodule

---
 crypto-js/aes/index.d.ts              |   3 +
 crypto-js/core/index.d.ts             |   3 +
 crypto-js/enc-base64/index.d.ts       |   4 +
 crypto-js/enc-hex/index.d.ts          |   4 +
 crypto-js/enc-latin1/index.d.ts       |   4 +
 crypto-js/enc-utf16/index.d.ts        |   4 +
 crypto-js/enc-utf8/index.d.ts         |   4 +
 crypto-js/evpkdf/index.d.ts           |   3 +
 crypto-js/format-hex/index.d.ts       |   4 +
 crypto-js/format-openssl/index.d.ts   |   4 +
 crypto-js/hmac-md5/index.d.ts         |   3 +
 crypto-js/hmac-ripemd160/index.d.ts   |   3 +
 crypto-js/hmac-sha1/index.d.ts        |   3 +
 crypto-js/hmac-sha224/index.d.ts      |   3 +
 crypto-js/hmac-sha256/index.d.ts      |   3 +
 crypto-js/hmac-sha3/index.d.ts        |   3 +
 crypto-js/hmac-sha384/index.d.ts      |   3 +
 crypto-js/hmac-sha512/index.d.ts      |   3 +
 crypto-js/index.d.ts                  | 237 +-------------------------
 crypto-js/lib-typedarrays/index.d.ts  |   2 +
 crypto-js/md5/index.d.ts              |   3 +
 crypto-js/mode-cfb/index.d.ts         |   4 +
 crypto-js/mode-ctr-gladman/index.d.ts |   4 +
 crypto-js/mode-ctr/index.d.ts         |   4 +
 crypto-js/mode-ecb/index.d.ts         |   4 +
 crypto-js/mode-ofb/index.d.ts         |   4 +
 crypto-js/pad-ansix923/index.d.ts     |   4 +
 crypto-js/pad-iso10126/index.d.ts     |   4 +
 crypto-js/pad-iso97971/index.d.ts     |   4 +
 crypto-js/pad-nopadding/index.d.ts    |   4 +
 crypto-js/pad-pkcs7/index.d.ts        |   4 +
 crypto-js/pad-zeropadding/index.d.ts  |   4 +
 crypto-js/pbkdf2/index.d.ts           |   3 +
 crypto-js/rabbit-legacy/index.d.ts    |   3 +
 crypto-js/rabbit/index.d.ts           |   3 +
 crypto-js/rc4/index.d.ts              |   3 +
 crypto-js/ripemd160/index.d.ts        |   3 +
 crypto-js/sha1/index.d.ts             |   3 +
 crypto-js/sha224/index.d.ts           |   3 +
 crypto-js/sha256/index.d.ts           |   3 +
 crypto-js/sha3/index.d.ts             |   3 +
 crypto-js/sha384/index.d.ts           |   3 +
 crypto-js/sha512/index.d.ts           |   3 +
 crypto-js/tripledes/index.d.ts        |   3 +
 crypto-js/x64-core/index.d.ts         |   3 +
 45 files changed, 152 insertions(+), 234 deletions(-)
 create mode 100644 crypto-js/aes/index.d.ts
 create mode 100644 crypto-js/core/index.d.ts
 create mode 100644 crypto-js/enc-base64/index.d.ts
 create mode 100644 crypto-js/enc-hex/index.d.ts
 create mode 100644 crypto-js/enc-latin1/index.d.ts
 create mode 100644 crypto-js/enc-utf16/index.d.ts
 create mode 100644 crypto-js/enc-utf8/index.d.ts
 create mode 100644 crypto-js/evpkdf/index.d.ts
 create mode 100644 crypto-js/format-hex/index.d.ts
 create mode 100644 crypto-js/format-openssl/index.d.ts
 create mode 100644 crypto-js/hmac-md5/index.d.ts
 create mode 100644 crypto-js/hmac-ripemd160/index.d.ts
 create mode 100644 crypto-js/hmac-sha1/index.d.ts
 create mode 100644 crypto-js/hmac-sha224/index.d.ts
 create mode 100644 crypto-js/hmac-sha256/index.d.ts
 create mode 100644 crypto-js/hmac-sha3/index.d.ts
 create mode 100644 crypto-js/hmac-sha384/index.d.ts
 create mode 100644 crypto-js/hmac-sha512/index.d.ts
 create mode 100644 crypto-js/lib-typedarrays/index.d.ts
 create mode 100644 crypto-js/md5/index.d.ts
 create mode 100644 crypto-js/mode-cfb/index.d.ts
 create mode 100644 crypto-js/mode-ctr-gladman/index.d.ts
 create mode 100644 crypto-js/mode-ctr/index.d.ts
 create mode 100644 crypto-js/mode-ecb/index.d.ts
 create mode 100644 crypto-js/mode-ofb/index.d.ts
 create mode 100644 crypto-js/pad-ansix923/index.d.ts
 create mode 100644 crypto-js/pad-iso10126/index.d.ts
 create mode 100644 crypto-js/pad-iso97971/index.d.ts
 create mode 100644 crypto-js/pad-nopadding/index.d.ts
 create mode 100644 crypto-js/pad-pkcs7/index.d.ts
 create mode 100644 crypto-js/pad-zeropadding/index.d.ts
 create mode 100644 crypto-js/pbkdf2/index.d.ts
 create mode 100644 crypto-js/rabbit-legacy/index.d.ts
 create mode 100644 crypto-js/rabbit/index.d.ts
 create mode 100644 crypto-js/rc4/index.d.ts
 create mode 100644 crypto-js/ripemd160/index.d.ts
 create mode 100644 crypto-js/sha1/index.d.ts
 create mode 100644 crypto-js/sha224/index.d.ts
 create mode 100644 crypto-js/sha256/index.d.ts
 create mode 100644 crypto-js/sha3/index.d.ts
 create mode 100644 crypto-js/sha384/index.d.ts
 create mode 100644 crypto-js/sha512/index.d.ts
 create mode 100644 crypto-js/tripledes/index.d.ts
 create mode 100644 crypto-js/x64-core/index.d.ts

diff --git a/crypto-js/aes/index.d.ts b/crypto-js/aes/index.d.ts
new file mode 100644
index 0000000000..4f435688c5
--- /dev/null
+++ b/crypto-js/aes/index.d.ts
@@ -0,0 +1,3 @@
+import { AES } from '../index';
+
+export = AES;
diff --git a/crypto-js/core/index.d.ts b/crypto-js/core/index.d.ts
new file mode 100644
index 0000000000..c5d6e00410
--- /dev/null
+++ b/crypto-js/core/index.d.ts
@@ -0,0 +1,3 @@
+import * as Core from '../index';
+
+export = Core;
diff --git a/crypto-js/enc-base64/index.d.ts b/crypto-js/enc-base64/index.d.ts
new file mode 100644
index 0000000000..55001a7115
--- /dev/null
+++ b/crypto-js/enc-base64/index.d.ts
@@ -0,0 +1,4 @@
+import { enc } from '../index';
+
+declare const Base64: typeof enc.Base64;
+export = Base64;
diff --git a/crypto-js/enc-hex/index.d.ts b/crypto-js/enc-hex/index.d.ts
new file mode 100644
index 0000000000..3718860123
--- /dev/null
+++ b/crypto-js/enc-hex/index.d.ts
@@ -0,0 +1,4 @@
+import { enc } from '../index';
+
+declare const Hex: typeof enc.Hex;
+export = Hex;
diff --git a/crypto-js/enc-latin1/index.d.ts b/crypto-js/enc-latin1/index.d.ts
new file mode 100644
index 0000000000..7f27822daf
--- /dev/null
+++ b/crypto-js/enc-latin1/index.d.ts
@@ -0,0 +1,4 @@
+import { enc } from '../index';
+
+declare const Latin1: typeof enc.Latin1;
+export = Latin1;
diff --git a/crypto-js/enc-utf16/index.d.ts b/crypto-js/enc-utf16/index.d.ts
new file mode 100644
index 0000000000..76fa98774a
--- /dev/null
+++ b/crypto-js/enc-utf16/index.d.ts
@@ -0,0 +1,4 @@
+import { enc } from '../index';
+
+declare const Utf16: typeof enc.Utf16;
+export = Utf16;
diff --git a/crypto-js/enc-utf8/index.d.ts b/crypto-js/enc-utf8/index.d.ts
new file mode 100644
index 0000000000..828dcb9391
--- /dev/null
+++ b/crypto-js/enc-utf8/index.d.ts
@@ -0,0 +1,4 @@
+import { enc } from '../index';
+
+declare const Utf8: typeof enc.Utf8;
+export = Utf8;
diff --git a/crypto-js/evpkdf/index.d.ts b/crypto-js/evpkdf/index.d.ts
new file mode 100644
index 0000000000..8946b9d3a1
--- /dev/null
+++ b/crypto-js/evpkdf/index.d.ts
@@ -0,0 +1,3 @@
+import { EvpKDF } from '../index';
+
+export = EvpKDF;
diff --git a/crypto-js/format-hex/index.d.ts b/crypto-js/format-hex/index.d.ts
new file mode 100644
index 0000000000..1b0f573824
--- /dev/null
+++ b/crypto-js/format-hex/index.d.ts
@@ -0,0 +1,4 @@
+import { format } from '../index';
+
+declare const Hex: typeof format.Hex;
+export = Hex;
diff --git a/crypto-js/format-openssl/index.d.ts b/crypto-js/format-openssl/index.d.ts
new file mode 100644
index 0000000000..02c35a3688
--- /dev/null
+++ b/crypto-js/format-openssl/index.d.ts
@@ -0,0 +1,4 @@
+import { format } from '../index';
+
+declare const OpenSSL: typeof format.OpenSSL;
+export = OpenSSL;
diff --git a/crypto-js/hmac-md5/index.d.ts b/crypto-js/hmac-md5/index.d.ts
new file mode 100644
index 0000000000..7240576710
--- /dev/null
+++ b/crypto-js/hmac-md5/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacMD5 } from '../index';
+
+export = HmacMD5;
diff --git a/crypto-js/hmac-ripemd160/index.d.ts b/crypto-js/hmac-ripemd160/index.d.ts
new file mode 100644
index 0000000000..6c371e9435
--- /dev/null
+++ b/crypto-js/hmac-ripemd160/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacRIPEMD160 } from '../index';
+
+export = HmacRIPEMD160;
diff --git a/crypto-js/hmac-sha1/index.d.ts b/crypto-js/hmac-sha1/index.d.ts
new file mode 100644
index 0000000000..1995cf87f6
--- /dev/null
+++ b/crypto-js/hmac-sha1/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacSHA1 } from '../index';
+
+export = HmacSHA1;
diff --git a/crypto-js/hmac-sha224/index.d.ts b/crypto-js/hmac-sha224/index.d.ts
new file mode 100644
index 0000000000..f25334c64c
--- /dev/null
+++ b/crypto-js/hmac-sha224/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacSHA224 } from '../index';
+
+export = HmacSHA224;
diff --git a/crypto-js/hmac-sha256/index.d.ts b/crypto-js/hmac-sha256/index.d.ts
new file mode 100644
index 0000000000..ca1a1ca267
--- /dev/null
+++ b/crypto-js/hmac-sha256/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacSHA256 } from '../index';
+
+export = HmacSHA256;
diff --git a/crypto-js/hmac-sha3/index.d.ts b/crypto-js/hmac-sha3/index.d.ts
new file mode 100644
index 0000000000..0fa0db9321
--- /dev/null
+++ b/crypto-js/hmac-sha3/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacSHA3 } from '../index';
+
+export = HmacSHA3;
diff --git a/crypto-js/hmac-sha384/index.d.ts b/crypto-js/hmac-sha384/index.d.ts
new file mode 100644
index 0000000000..2e17420c1b
--- /dev/null
+++ b/crypto-js/hmac-sha384/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacSHA384 } from '../index';
+
+export = HmacSHA384;
diff --git a/crypto-js/hmac-sha512/index.d.ts b/crypto-js/hmac-sha512/index.d.ts
new file mode 100644
index 0000000000..439b2ffd5e
--- /dev/null
+++ b/crypto-js/hmac-sha512/index.d.ts
@@ -0,0 +1,3 @@
+import { HmacSHA512 } from '../index';
+
+export = HmacSHA512;
diff --git a/crypto-js/index.d.ts b/crypto-js/index.d.ts
index a2c0ee381d..a8068161e1 100644
--- a/crypto-js/index.d.ts
+++ b/crypto-js/index.d.ts
@@ -3,6 +3,9 @@
 // Definitions by: Michael Zabka <https://github.com/misak113/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+export = CryptoJS;
+export as namespace CryptoJS;
+
 declare var CryptoJS: CryptoJS.Hashes;
 declare namespace CryptoJS {
 	type Hash = (message: string, key?: string, ...options: any[]) => string;
@@ -112,237 +115,3 @@ declare namespace CryptoJS {
 	}
 
 }
-
-declare module "crypto-js" {
-	var CryptoJS: CryptoJS.Hashes;
-	export = CryptoJS;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/core" {
-	var core: any;
-	export = core;
-}
-
-declare module "crypto-js/x64-core" {
-	var x64: any;
-	export = x64;
-}
-
-declare module "crypto-js/lib-typedarrays" {
-	var libWordArray: any;
-	export = libWordArray;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/md5" {
-	var MD5: CryptoJS.Hash;
-	export = MD5;
-}
-
-declare module "crypto-js/sha1" {
-	var SHA1: CryptoJS.Hash;
-	export = SHA1;
-}
-
-declare module "crypto-js/sha256" {
-	var SHA256: CryptoJS.Hash;
-	export = SHA256;
-}
-
-declare module "crypto-js/sha224" {
-	var SHA224: CryptoJS.Hash;
-	export = SHA224;
-}
-
-declare module "crypto-js/sha512" {
-	var SHA512: CryptoJS.Hash;
-	export = SHA512;
-}
-
-declare module "crypto-js/sha384" {
-	var SHA384: CryptoJS.Hash;
-	export = SHA384;
-}
-
-declare module "crypto-js/sha3" {
-	var SHA3: CryptoJS.Hash;
-	export = SHA3;
-}
-
-declare module "crypto-js/ripemd160" {
-	var RIPEMD160: CryptoJS.Hash;
-	export = RIPEMD160;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/hmac-md5" {
-	var HmacMD5: CryptoJS.Hash;
-	export = HmacMD5;
-}
-
-declare module "crypto-js/hmac-sha1" {
-	var HmacSHA1: CryptoJS.Hash;
-	export = HmacSHA1;
-}
-
-declare module "crypto-js/hmac-sha256" {
-	var HmacSHA256: CryptoJS.Hash;
-	export = HmacSHA256;
-}
-
-declare module "crypto-js/hmac-sha224" {
-	var HmacSHA224: CryptoJS.Hash;
-	export = HmacSHA224;
-}
-
-declare module "crypto-js/hmac-sha512" {
-	var HmacSHA512: CryptoJS.Hash;
-	export = HmacSHA512;
-}
-
-declare module "crypto-js/hmac-sha384" {
-	var HmacSHA384: CryptoJS.Hash;
-	export = HmacSHA384;
-}
-
-declare module "crypto-js/hmac-sha3" {
-	var HmacSHA3: CryptoJS.Hash;
-	export = HmacSHA3;
-}
-
-declare module "crypto-js/hmac-ripemd160" {
-	var HmacRIPEMD160: CryptoJS.Hash;
-	export = HmacRIPEMD160;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/pbkdf2" {
-	var PBKDF2: CryptoJS.Hash;
-	export = PBKDF2;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/aes" {
-	var AES: CryptoJS.Cipher;
-	export = AES;
-}
-
-declare module "crypto-js/tripledes" {
-	var TripleDES: CryptoJS.Cipher;
-	export = TripleDES;
-}
-
-declare module "crypto-js/rc4" {
-	var RC4: CryptoJS.Cipher;
-	export = RC4;
-}
-
-declare module "crypto-js/rabbit" {
-	var Rabbit: CryptoJS.Cipher;
-	export = Rabbit;
-}
-
-declare module "crypto-js/rabbit-legacy" {
-	var RabbitLegacy: CryptoJS.Cipher;
-	export = RabbitLegacy;
-}
-
-declare module "crypto-js/evpkdf" {
-	var EvpKDF: CryptoJS.Cipher;
-	export = EvpKDF;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/format-openssl" {
-	var FormatOpenssl: any;
-	export = FormatOpenssl;
-}
-
-declare module "crypto-js/format-hex" {
-	var FormatHex: any;
-	export = FormatHex;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/enc-latin1" {
-	var encLatin1: CryptoJS.Encoder;
-	export = encLatin1;
-}
-
-declare module "crypto-js/enc-utf8" {
-	var encUtf8: CryptoJS.Encoder;
-	export = encUtf8;
-}
-
-declare module "crypto-js/enc-hex" {
-	var encHex: CryptoJS.Encoder;
-	export = encHex;
-}
-
-declare module "crypto-js/enc-utf16" {
-	var encUtf16: CryptoJS.Encoder;
-	export = encUtf16;
-}
-
-declare module "crypto-js/enc-base64" {
-	var encBase64: CryptoJS.Encoder;
-	export = encBase64;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/mode-cfb" {
-	var modeCFB: CryptoJS.Mode;
-	export = modeCFB;
-}
-
-declare module "crypto-js/mode-ctr" {
-	var modeCTR: CryptoJS.Mode;
-	export = modeCTR;
-}
-
-declare module "crypto-js/mode-ctr-gladman" {
-	var modeCTRGladman: CryptoJS.Mode;
-	export = modeCTRGladman;
-}
-
-declare module "crypto-js/mode-ofb" {
-	var modeOFB: CryptoJS.Mode;
-	export = modeOFB;
-}
-
-declare module "crypto-js/mode-ecb" {
-	var modeECB: CryptoJS.Mode;
-	export = modeECB;
-}
-
-/* --------------------------------- */
-declare module "crypto-js/pad-pkcs7" {
-	var padPkcs7: CryptoJS.Padding;
-	export = padPkcs7;
-}
-
-declare module "crypto-js/pad-ansix923" {
-	var padAnsiX923: CryptoJS.Padding;
-	export = padAnsiX923;
-}
-
-declare module "crypto-js/pad-iso10126" {
-	var padIso10126: CryptoJS.Padding;
-	export = padIso10126;
-}
-
-declare module "crypto-js/pad-iso97971" {
-	var padIso97971: CryptoJS.Padding;
-	export = padIso97971;
-}
-
-declare module "crypto-js/pad-zeropadding" {
-	var padZeroPadding: CryptoJS.Padding;
-	export = padZeroPadding;
-}
-
-declare module "crypto-js/pad-nopadding" {
-	var padNoPadding: CryptoJS.Padding;
-	export = padNoPadding;
-}
diff --git a/crypto-js/lib-typedarrays/index.d.ts b/crypto-js/lib-typedarrays/index.d.ts
new file mode 100644
index 0000000000..91c5a7933b
--- /dev/null
+++ b/crypto-js/lib-typedarrays/index.d.ts
@@ -0,0 +1,2 @@
+declare const libWordArray: any;
+export = libWordArray;
diff --git a/crypto-js/md5/index.d.ts b/crypto-js/md5/index.d.ts
new file mode 100644
index 0000000000..faa064511e
--- /dev/null
+++ b/crypto-js/md5/index.d.ts
@@ -0,0 +1,3 @@
+import { MD5 } from '../index';
+
+export = MD5;
diff --git a/crypto-js/mode-cfb/index.d.ts b/crypto-js/mode-cfb/index.d.ts
new file mode 100644
index 0000000000..74c5c6e3d1
--- /dev/null
+++ b/crypto-js/mode-cfb/index.d.ts
@@ -0,0 +1,4 @@
+import { mode } from '../index';
+
+declare const CFB: typeof mode.CFB;
+export = CFB;
diff --git a/crypto-js/mode-ctr-gladman/index.d.ts b/crypto-js/mode-ctr-gladman/index.d.ts
new file mode 100644
index 0000000000..3ca8f8b367
--- /dev/null
+++ b/crypto-js/mode-ctr-gladman/index.d.ts
@@ -0,0 +1,4 @@
+import { mode } from '../index';
+
+declare const CTRGladman: typeof mode.CTRGladman;
+export = CTRGladman;
diff --git a/crypto-js/mode-ctr/index.d.ts b/crypto-js/mode-ctr/index.d.ts
new file mode 100644
index 0000000000..6007a4ca88
--- /dev/null
+++ b/crypto-js/mode-ctr/index.d.ts
@@ -0,0 +1,4 @@
+import { mode } from '../index';
+
+declare const CTR: typeof mode.CTR;
+export = CTR;
diff --git a/crypto-js/mode-ecb/index.d.ts b/crypto-js/mode-ecb/index.d.ts
new file mode 100644
index 0000000000..569d2b2286
--- /dev/null
+++ b/crypto-js/mode-ecb/index.d.ts
@@ -0,0 +1,4 @@
+import { mode } from '../index';
+
+declare const ECB: typeof mode.ECB;
+export = ECB;
diff --git a/crypto-js/mode-ofb/index.d.ts b/crypto-js/mode-ofb/index.d.ts
new file mode 100644
index 0000000000..484406979d
--- /dev/null
+++ b/crypto-js/mode-ofb/index.d.ts
@@ -0,0 +1,4 @@
+import { mode } from '../index';
+
+declare const OFB: typeof mode.OFB;
+export = OFB;
diff --git a/crypto-js/pad-ansix923/index.d.ts b/crypto-js/pad-ansix923/index.d.ts
new file mode 100644
index 0000000000..2bb6c2dffb
--- /dev/null
+++ b/crypto-js/pad-ansix923/index.d.ts
@@ -0,0 +1,4 @@
+import { pad } from '../index';
+
+declare const AnsiX923: typeof pad.AnsiX923;
+export = AnsiX923;
diff --git a/crypto-js/pad-iso10126/index.d.ts b/crypto-js/pad-iso10126/index.d.ts
new file mode 100644
index 0000000000..6e52e96197
--- /dev/null
+++ b/crypto-js/pad-iso10126/index.d.ts
@@ -0,0 +1,4 @@
+import { pad } from '../index';
+
+declare const Iso10126: typeof pad.Iso10126;
+export = Iso10126;
diff --git a/crypto-js/pad-iso97971/index.d.ts b/crypto-js/pad-iso97971/index.d.ts
new file mode 100644
index 0000000000..0ab1cecbfb
--- /dev/null
+++ b/crypto-js/pad-iso97971/index.d.ts
@@ -0,0 +1,4 @@
+import { pad } from '../index';
+
+declare const Iso97971: typeof pad.Iso97971;
+export = Iso97971;
diff --git a/crypto-js/pad-nopadding/index.d.ts b/crypto-js/pad-nopadding/index.d.ts
new file mode 100644
index 0000000000..f71bb2de73
--- /dev/null
+++ b/crypto-js/pad-nopadding/index.d.ts
@@ -0,0 +1,4 @@
+import { pad } from '../index';
+
+declare const NoPadding: typeof pad.NoPadding;
+export = NoPadding;
diff --git a/crypto-js/pad-pkcs7/index.d.ts b/crypto-js/pad-pkcs7/index.d.ts
new file mode 100644
index 0000000000..1b194673a2
--- /dev/null
+++ b/crypto-js/pad-pkcs7/index.d.ts
@@ -0,0 +1,4 @@
+import { pad } from '../index';
+
+declare const Pkcs7: typeof pad.Pkcs7;
+export = Pkcs7;
diff --git a/crypto-js/pad-zeropadding/index.d.ts b/crypto-js/pad-zeropadding/index.d.ts
new file mode 100644
index 0000000000..cf481402ab
--- /dev/null
+++ b/crypto-js/pad-zeropadding/index.d.ts
@@ -0,0 +1,4 @@
+import { pad } from '../index';
+
+declare const ZeroPadding: typeof pad.ZeroPadding;
+export = ZeroPadding;
diff --git a/crypto-js/pbkdf2/index.d.ts b/crypto-js/pbkdf2/index.d.ts
new file mode 100644
index 0000000000..e242e6fe05
--- /dev/null
+++ b/crypto-js/pbkdf2/index.d.ts
@@ -0,0 +1,3 @@
+import { PBKDF2 } from '../index';
+
+export = PBKDF2;
diff --git a/crypto-js/rabbit-legacy/index.d.ts b/crypto-js/rabbit-legacy/index.d.ts
new file mode 100644
index 0000000000..6befe37563
--- /dev/null
+++ b/crypto-js/rabbit-legacy/index.d.ts
@@ -0,0 +1,3 @@
+import { RabbitLegacy } from '../index';
+
+export = RabbitLegacy;
diff --git a/crypto-js/rabbit/index.d.ts b/crypto-js/rabbit/index.d.ts
new file mode 100644
index 0000000000..f708a6f20b
--- /dev/null
+++ b/crypto-js/rabbit/index.d.ts
@@ -0,0 +1,3 @@
+import { Rabbit } from '../index';
+
+export = Rabbit;
diff --git a/crypto-js/rc4/index.d.ts b/crypto-js/rc4/index.d.ts
new file mode 100644
index 0000000000..38a929f490
--- /dev/null
+++ b/crypto-js/rc4/index.d.ts
@@ -0,0 +1,3 @@
+import { RC4 } from '../index';
+
+export = RC4;
diff --git a/crypto-js/ripemd160/index.d.ts b/crypto-js/ripemd160/index.d.ts
new file mode 100644
index 0000000000..90e3e770ce
--- /dev/null
+++ b/crypto-js/ripemd160/index.d.ts
@@ -0,0 +1,3 @@
+import { RIPEMD160 } from '../index';
+
+export = RIPEMD160;
diff --git a/crypto-js/sha1/index.d.ts b/crypto-js/sha1/index.d.ts
new file mode 100644
index 0000000000..14fb4d2a6b
--- /dev/null
+++ b/crypto-js/sha1/index.d.ts
@@ -0,0 +1,3 @@
+import { SHA1 } from '../index';
+
+export = SHA1;
diff --git a/crypto-js/sha224/index.d.ts b/crypto-js/sha224/index.d.ts
new file mode 100644
index 0000000000..3ff1ff4596
--- /dev/null
+++ b/crypto-js/sha224/index.d.ts
@@ -0,0 +1,3 @@
+import { SHA224 } from '../index';
+
+export = SHA224;
diff --git a/crypto-js/sha256/index.d.ts b/crypto-js/sha256/index.d.ts
new file mode 100644
index 0000000000..59781b01f3
--- /dev/null
+++ b/crypto-js/sha256/index.d.ts
@@ -0,0 +1,3 @@
+import { SHA256 } from '../index';
+
+export = SHA256;
diff --git a/crypto-js/sha3/index.d.ts b/crypto-js/sha3/index.d.ts
new file mode 100644
index 0000000000..241574a711
--- /dev/null
+++ b/crypto-js/sha3/index.d.ts
@@ -0,0 +1,3 @@
+import { SHA3 } from '../index';
+
+export = SHA3;
diff --git a/crypto-js/sha384/index.d.ts b/crypto-js/sha384/index.d.ts
new file mode 100644
index 0000000000..5bad55498a
--- /dev/null
+++ b/crypto-js/sha384/index.d.ts
@@ -0,0 +1,3 @@
+import { SHA384 } from '../index';
+
+export = SHA384;
diff --git a/crypto-js/sha512/index.d.ts b/crypto-js/sha512/index.d.ts
new file mode 100644
index 0000000000..0f764329e2
--- /dev/null
+++ b/crypto-js/sha512/index.d.ts
@@ -0,0 +1,3 @@
+import { SHA512 } from '../index';
+
+export = SHA512;
diff --git a/crypto-js/tripledes/index.d.ts b/crypto-js/tripledes/index.d.ts
new file mode 100644
index 0000000000..ea22173d98
--- /dev/null
+++ b/crypto-js/tripledes/index.d.ts
@@ -0,0 +1,3 @@
+import { TripleDES } from '../index';
+
+export = TripleDES;
diff --git a/crypto-js/x64-core/index.d.ts b/crypto-js/x64-core/index.d.ts
new file mode 100644
index 0000000000..1ef7a67477
--- /dev/null
+++ b/crypto-js/x64-core/index.d.ts
@@ -0,0 +1,3 @@
+import * as X64Core  from '../index';
+
+export = X64Core;

From 9be29e7b530932ecc1b0165713a1e49936de78a1 Mon Sep 17 00:00:00 2001
From: darlin <duxiaodong@darlin.me>
Date: Wed, 25 Jan 2017 15:10:10 +0800
Subject: [PATCH 25/87] add files in tsconfig

---
 crypto-js/lib-typedarrays/index.d.ts |  4 +--
 crypto-js/tsconfig.json              | 48 ++++++++++++++++++++++++++--
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/crypto-js/lib-typedarrays/index.d.ts b/crypto-js/lib-typedarrays/index.d.ts
index 91c5a7933b..761e38b1cd 100644
--- a/crypto-js/lib-typedarrays/index.d.ts
+++ b/crypto-js/lib-typedarrays/index.d.ts
@@ -1,2 +1,2 @@
-declare const libWordArray: any;
-export = libWordArray;
+declare const LibTypedarrays: any;
+export = LibTypedarrays;
diff --git a/crypto-js/tsconfig.json b/crypto-js/tsconfig.json
index 94793c83ae..7fc335c24a 100644
--- a/crypto-js/tsconfig.json
+++ b/crypto-js/tsconfig.json
@@ -18,6 +18,50 @@
     },
     "files": [
         "index.d.ts",
-        "crypto-js-tests.ts"
+        "crypto-js-tests.ts",
+        "core/index.d.ts",
+        "x64-core/index.d.ts",
+        "lib-typedarrays/index.d.ts",
+        "md5/index.d.ts",
+        "sha1/index.d.ts",
+        "sha256/index.d.ts",
+        "sha224/index.d.ts",
+        "sha512/index.d.ts",
+        "sha384/index.d.ts",
+        "sha3/index.d.ts",
+        "ripemd160/index.d.ts",
+        "hmac-md5/index.d.ts",
+        "hmac-sha1/index.d.ts",
+        "hmac-sha256/index.d.ts",
+        "hmac-sha224/index.d.ts",
+        "hmac-sha512/index.d.ts",
+        "hmac-sha384/index.d.ts",
+        "hmac-sha3/index.d.ts",
+        "hmac-ripemd160/index.d.ts",
+        "pbkdf2/index.d.ts",
+        "aes/index.d.ts",
+        "tripledes/index.d.ts",
+        "rc4/index.d.ts",
+        "rabbit/index.d.ts",
+        "rabbit-legacy/index.d.ts",
+        "evpkdf/index.d.ts",
+        "format-openssl/index.d.ts",
+        "format-hex/index.d.ts",
+        "enc-latin1/index.d.ts",
+        "enc-utf8/index.d.ts",
+        "enc-hex/index.d.ts",
+        "enc-utf16/index.d.ts",
+        "enc-base64/index.d.ts",
+        "mode-cfb/index.d.ts",
+        "mode-ctr/index.d.ts",
+        "mode-ctr-gladman/index.d.ts",
+        "mode-ofb/index.d.ts",
+        "mode-ecb/index.d.ts",
+        "pad-pkcs7/index.d.ts",
+        "pad-ansix923/index.d.ts",
+        "pad-iso10126/index.d.ts",
+        "pad-iso97971/index.d.ts",
+        "pad-zeropadding/index.d.ts",
+        "pad-nopadding/index.d.ts"
     ]
-}
\ No newline at end of file
+}

From d2febcc480606fab9d8564fd6e2d77f576ae39d7 Mon Sep 17 00:00:00 2001
From: darlin <duxiaodong@darlin.me>
Date: Wed, 25 Jan 2017 16:03:50 +0800
Subject: [PATCH 26/87] add submodule tests

---
 crypto-js/index.d.ts              |   1 -
 crypto-js/test/submodule-tests.ts | 184 ++++++++++++++++++++++++++++++
 crypto-js/tsconfig.json           |   1 +
 3 files changed, 185 insertions(+), 1 deletion(-)
 create mode 100644 crypto-js/test/submodule-tests.ts

diff --git a/crypto-js/index.d.ts b/crypto-js/index.d.ts
index a8068161e1..07a8d18dfc 100644
--- a/crypto-js/index.d.ts
+++ b/crypto-js/index.d.ts
@@ -113,5 +113,4 @@ declare namespace CryptoJS {
 			NoPadding: Padding;
 		};
 	}
-
 }
diff --git a/crypto-js/test/submodule-tests.ts b/crypto-js/test/submodule-tests.ts
new file mode 100644
index 0000000000..0cfd8cd83f
--- /dev/null
+++ b/crypto-js/test/submodule-tests.ts
@@ -0,0 +1,184 @@
+import Core = require('../core');
+import X64Core = require('../x64-core');
+import LibTypedarrays = require('../lib-typedarrays');
+// ---
+import MD5 = require('../md5');
+import SHA1 = require('../sha1');
+import SHA256 = require('../sha256');
+import SHA224 = require('../sha224');
+import SHA512 = require('../sha512');
+import SHA384 = require('../sha384');
+import SHA3 = require('../sha3');
+import RIPEMD160 = require('../ripemd160');
+// ---
+import HmacMD5 = require('../hmac-md5');
+import HmacSHA1 = require('../hmac-sha1');
+import HmacSHA256 = require('../hmac-sha256');
+import HmacSHA224 = require('../hmac-sha224');
+import HmacSHA512 = require('../hmac-sha512');
+import HmacSHA384 = require('../hmac-sha384');
+import HmacSHA3 = require('../hmac-sha3');
+import HmacRIPEMD160 = require('../hmac-ripemd160');
+// ---
+import PBKDF2 = require('../pbkdf2');
+// ---
+import AES = require('../aes');
+import TripleDES = require('../tripledes');
+import RC4 = require('../rc4');
+import Rabbit = require('../rabbit');
+import RabbitLegacy = require('../rabbit-legacy');
+import EvpKDF = require('../evpkdf');
+// ---
+import FormatOpenSSL = require('../format-openssl');
+import FormatHex = require('../format-hex');
+// ---
+import EncLatin1 = require('../enc-latin1');
+import EncUtf8 = require('../enc-utf8');
+import EncHex = require('../enc-hex');
+import EncUtf16 = require('../enc-utf16');
+import EncBase64 = require('../enc-base64');
+// ---
+import ModeCFB = require('../mode-cfb');
+import ModeCTR = require('../mode-ctr');
+import ModeCTRGladman = require('../mode-ctr-gladman');
+import ModeOFB = require('../mode-ofb');
+import ModeECB = require('../mode-ecb');
+// ---
+import PadPkcs7 = require('../pad-pkcs7');
+import PadAnsiX923 = require('../pad-ansix923');
+import PadIso10126 = require('../pad-iso10126');
+import PadIso97971 = require('../pad-iso97971');
+import PadZeroPadding = require('../pad-zeropadding');
+import PadNoPadding = require('../pad-nopadding');
+
+// Hashers
+var str: string;
+str = MD5('some message');
+str = MD5('some message', 'some key');
+
+str = SHA1('some message');
+str = SHA1('some message', 'some key', { any: true });
+
+str = FormatOpenSSL('some message');
+str = FormatOpenSSL('some message', 'some key');
+
+
+// Ciphers
+var encrypted: CryptoJS.WordArray;
+var decrypted: CryptoJS.DecryptedMessage;
+
+encrypted = <CryptoJS.WordArray>AES.encrypt("Message", "Secret Passphrase");
+decrypted = AES.decrypt(encrypted, "Secret Passphrase");
+
+encrypted = <CryptoJS.WordArray>Core.DES.encrypt("Message", "Secret Passphrase");
+decrypted = Core.DES.decrypt(encrypted, "Secret Passphrase");
+
+encrypted = TripleDES.encrypt("Message", "Secret Passphrase");
+decrypted = TripleDES.decrypt(encrypted, "Secret Passphrase");
+
+
+encrypted = Rabbit.encrypt("Message", "Secret Passphrase");
+decrypted = Rabbit.decrypt(encrypted, "Secret Passphrase");
+
+encrypted = RC4.encrypt("Message", "Secret Passphrase");
+decrypted = RC4.decrypt(encrypted, "Secret Passphrase");
+
+encrypted = Core.RC4Drop.encrypt("Message", "Secret Passphrase");
+encrypted = Core.RC4Drop.encrypt("Message", "Secret Passphrase", { drop: 3072 / 4 });
+decrypted = Core.RC4Drop.decrypt(encrypted, "Secret Passphrase", { drop: 3072 / 4 });
+
+var key = EncHex.parse('000102030405060708090a0b0c0d0e0f');
+var iv = EncHex.parse('101112131415161718191a1b1c1d1e1f');
+encrypted = AES.encrypt("Message", key, { iv: iv });
+
+encrypted = AES.encrypt("Message", "Secret Passphrase", {
+	mode: ModeCFB,
+	padding: PadAnsiX923
+});
+
+
+// The Cipher Output
+encrypted = AES.encrypt("Message", "Secret Passphrase");
+alert(encrypted.key);
+// 74eb593087a982e2a6f5dded54ecd96d1fd0f3d44a58728cdcd40c55227522223
+alert(encrypted.iv);
+// 7781157e2629b094f0e3dd48c4d786115
+alert(encrypted.salt);
+// 7a25f9132ec6a8b34
+alert(encrypted.ciphertext);
+// 73e54154a15d1beeb509d9e12f1e462a0
+alert(encrypted);
+// U2FsdGVkX1+iX5Ey7GqLND5UFUoV0b7rUJ2eEvHkYqA=
+
+var JsonFormatter = {
+	stringify: function(cipherParams: any) {
+		// create json object with ciphertext
+		var jsonObj: any = {
+			ct: cipherParams.ciphertext.toString(EncBase64)
+		};
+		// optionally add iv and salt
+		if (cipherParams.iv) {
+			jsonObj.iv = cipherParams.iv.toString();
+		}
+		if (cipherParams.salt) {
+			jsonObj.s = cipherParams.salt.toString();
+		}
+		// stringify json object
+		return JSON.stringify(jsonObj);
+	},
+	parse: function (jsonStr: any) {
+		// parse json string
+		var jsonObj = JSON.parse(jsonStr);
+		// extract ciphertext from json object, and create cipher params object
+		var cipherParams = (<any>Core).lib.CipherParams.create({
+			ciphertext: EncBase64.parse(jsonObj.ct)
+		});
+		// optionally extract iv and salt
+		if (jsonObj.iv) {
+			cipherParams.iv = EncHex.parse(jsonObj.iv);
+		}
+		if (jsonObj.s) {
+			cipherParams.salt = EncHex.parse(jsonObj.s);
+		} return cipherParams;
+	}
+};
+encrypted = AES.encrypt("Message", "Secret Passphrase", {
+	format: JsonFormatter
+});
+alert(encrypted);
+// {"ct":"tZ4MsEnfbcDOwqau68aOrQ==","iv":"8a8c8fd8fe33743d3638737ea4a00698","s":"ba06373c8f57179c"}
+decrypted = AES.decrypt(encrypted, "Secret Passphrase", {
+	format: JsonFormatter
+});
+alert(decrypted.toString(EncUtf8)); // Message
+
+
+// Progressive Ciphering
+var key = EncHex.parse('000102030405060708090a0b0c0d0e0f');
+var iv = EncHex.parse('101112131415161718191a1b1c1d1e1f');
+var aesEncryptor = Core.algo.AES.createEncryptor(key, { iv: iv });
+var ciphertextPart1 = aesEncryptor.process("Message Part 1");
+var ciphertextPart2 = aesEncryptor.process("Message Part 2");
+var ciphertextPart3 = aesEncryptor.process("Message Part 3");
+var ciphertextPart4 = aesEncryptor.finalize();
+var aesDecryptor = Core.algo.AES.createDecryptor(key, { iv: iv });
+var plaintextPart1 = aesDecryptor.process(ciphertextPart1);
+var plaintextPart2 = aesDecryptor.process(ciphertextPart2);
+var plaintextPart3 = aesDecryptor.process(ciphertextPart3);
+var plaintextPart4 = aesDecryptor.process(ciphertextPart4);
+var plaintextPart5 = aesDecryptor.finalize();
+
+
+// Encoders
+var words = EncBase64.parse('SGVsbG8sIFdvcmxkIQ==');
+var base64 = EncBase64.stringify(words);
+var words = EncLatin1.parse('Hello, World!');
+var latin1 = EncLatin1.stringify(words);
+var words = EncHex.parse('48656c6c6f2c20576f726c6421');
+var hex = EncHex.stringify(words);
+var words = EncUtf8.parse('𤭢');
+var utf8 = EncUtf8.stringify(words);
+var words = EncUtf16.parse('Hello, World!');
+var utf16 = EncUtf16.stringify(words);
+var words = Core.enc.Utf16LE.parse('Hello, World!');
+var utf16 = Core.enc.Utf16LE.stringify(words);
diff --git a/crypto-js/tsconfig.json b/crypto-js/tsconfig.json
index 7fc335c24a..10865613d3 100644
--- a/crypto-js/tsconfig.json
+++ b/crypto-js/tsconfig.json
@@ -19,6 +19,7 @@
     "files": [
         "index.d.ts",
         "crypto-js-tests.ts",
+        "test/submodule-tests.ts",
         "core/index.d.ts",
         "x64-core/index.d.ts",
         "lib-typedarrays/index.d.ts",

From b2af2d23e5c0ff1f2e74390f6d93752a6631d594 Mon Sep 17 00:00:00 2001
From: Pablo Moleri <pmoleri@infragistics.com>
Date: Wed, 25 Jan 2017 10:29:43 -0300
Subject: [PATCH 27/87] Move getLocation "Axis" overloads before string ones

---
 webdriverio/index.d.ts | 35 ++++++++++-------------------------
 1 file changed, 10 insertions(+), 25 deletions(-)

diff --git a/webdriverio/index.d.ts b/webdriverio/index.d.ts
index f033ec2bfc..b79b17e98d 100644
--- a/webdriverio/index.d.ts
+++ b/webdriverio/index.d.ts
@@ -352,37 +352,22 @@ declare namespace WebdriverIO {
         ): Client<P>;
         getHTML<P>(includeSelectorTag: boolean): Client<P>;
 
-        getLocation(selector?: string): Location;
-        getLocation(selector: string, axis: Axis): number;
         getLocation(axis: Axis): number;
-        getLocation<P>(selector?: string): Client<P>;
-        getLocation<P>(
-            selector: string,
-            axis: Axis
-        ): Client<P>;
         getLocation<P>(axis: Axis): Client<P>;
+        getLocation(selector?: string): Location;
+        getLocation<P>(selector?: string): Client<P>;
+        getLocation(selector: string, axis: Axis): number;
+        getLocation<P>(selector: string, axis: Axis): Client<P>;
 
-        getLocationInView(selector: string): Location;
-        getLocationInView(selector: string): Location[];
-        getLocationInView(): Location;
-        getLocationInView(): Location[];
-        getLocationInView(
-            selector: string,
-            axis: Axis
-        ): number;
-        getLocationInView(
-            selector: string,
-            axis: Axis
-        ): number[];
         getLocationInView(axis: Axis): number;
         getLocationInView(axis: Axis): number[];
-        getLocationInView<P>(selector?: string): Client<P>;
-        getLocationInView<P>(
-            selector: string,
-            axis: Axis
-        ): Client<P>;
         getLocationInView<P>(axis: Axis): Client<P>;
-
+        getLocationInView(selector?: string): Location;
+        getLocationInView(selector?: string): Location[];
+        getLocationInView<P>(selector?: string): Client<P>;
+        getLocationInView(selector: string, axis: Axis): number;
+        getLocationInView(selector: string, axis: Axis): number[];
+        getLocationInView<P>(selector: string, axis: Axis): Client<P>;
 
         getSource(): Client<string>;
         getSource<P>(): Client<P>;

From 9294d370402f80b83a397cca709897623ca1f1f1 Mon Sep 17 00:00:00 2001
From: "LAWO\\heinigu1" <ulrich.heiniger@lawo.com>
Date: Wed, 25 Jan 2017 15:58:19 +0100
Subject: [PATCH 28/87] Add tv4

---
 chai-json-schema/chai-json-schema-tests.ts | 20 +++++++++++++++++---
 chai-json-schema/index.d.ts                |  5 +++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/chai-json-schema/chai-json-schema-tests.ts b/chai-json-schema/chai-json-schema-tests.ts
index 8559d3caae..d0c1234e17 100644
--- a/chai-json-schema/chai-json-schema-tests.ts
+++ b/chai-json-schema/chai-json-schema-tests.ts
@@ -9,19 +9,19 @@ import ChaiJsonSchema = require('chai-json-schema');
 chai.use(ChaiJsonSchema);
 chai.should();
 
-let goodApple = {
+const goodApple = {
     skin: 'thin',
     colors: ['red', 'green', 'yellow'],
     taste: 10
 };
 
-let badApple = {
+const badApple = {
     colors: ['brown'],
     taste: 0,
     worms: 2
 };
 
-let fruitSchema = {
+const fruitSchema = {
     title: 'fresh fruit schema v1',
     type: 'object',
     required: ['skin', 'colors', 'taste'],
@@ -54,3 +54,17 @@ badApple.should.not.be.jsonSchema(fruitSchema);
 //tdd style
 assert.jsonSchema(goodApple, fruitSchema);
 assert.notJsonSchema(badApple, fruitSchema);
+
+// tv4
+const schema = {
+    items: {
+        type: 'boolean'
+    }
+};
+
+const data1 = [true, false];
+const data2 = [true, 123];
+
+expect(chai.tv4.validate(data1, schema)).to.be.true;
+expect(chai.tv4.validate(data2, schema)).to.be.false;
+
diff --git a/chai-json-schema/index.d.ts b/chai-json-schema/index.d.ts
index e66e2c96af..1498510f9f 100644
--- a/chai-json-schema/index.d.ts
+++ b/chai-json-schema/index.d.ts
@@ -5,6 +5,7 @@
 
 // <reference types="node"/>
 // <reference types="chai" />
+import tv4 = require('tv4');
 
 declare global {
 	namespace Chai {
@@ -16,6 +17,10 @@ declare global {
 		export interface LanguageChains {
 			jsonSchema(schema: any, msg?: string): void;
 		}
+
+		export interface ChaiStatic {
+			tv4: tv4.TV4;
+		}
 	}
 }
 

From 201dab6133daa473861a04631e2e6bc1abe914a8 Mon Sep 17 00:00:00 2001
From: york yao <yaoao12306@outlook.com>
Date: Wed, 25 Jan 2017 23:58:49 +0800
Subject: [PATCH 29/87] add types of node-zookeeper-client

---
 node-zookeeper-client/index.d.ts              | 168 ++++++++++++
 .../node-zookeeper-client-tests.ts            | 253 ++++++++++++++++++
 node-zookeeper-client/tsconfig.json           |  22 ++
 node-zookeeper-client/tslint.json             |   1 +
 4 files changed, 444 insertions(+)
 create mode 100644 node-zookeeper-client/index.d.ts
 create mode 100644 node-zookeeper-client/node-zookeeper-client-tests.ts
 create mode 100644 node-zookeeper-client/tsconfig.json
 create mode 100644 node-zookeeper-client/tslint.json

diff --git a/node-zookeeper-client/index.d.ts b/node-zookeeper-client/index.d.ts
new file mode 100644
index 0000000000..f405aeffc7
--- /dev/null
+++ b/node-zookeeper-client/index.d.ts
@@ -0,0 +1,168 @@
+// Type definitions for Jasmine 2.5
+// Project: https://github.com/alexguan/node-zookeeper-client
+// Definitions by: York Yao <https://github.com/plantain-00/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+import * as EventEmitter from "events";
+
+export class Id {
+    scheme: string;
+    id: string;
+    constructor(scheme: string, id: string);
+}
+
+export class ACL {
+    perms: number;
+    id: Id;
+    constructor(perms: number, id: Id);
+}
+
+export const Permission: {
+    READ: number,
+    WRITE: number,
+    CREATE: number,
+    DELETE: number,
+    ADMIN: number,
+    ALL: number,
+};
+
+export interface Stat {
+    czxid: number;
+    mzxid: number;
+    ctime: number;
+    mtime: number;
+    version: number;
+    cversion: number;
+    aversion: number;
+    ephemeralOwner: number;
+    dataLength: number;
+    numChildren: number;
+    pzxid: number;
+}
+
+export class State {
+    static DISCONNECTED: State;
+    static SYNC_CONNECTED: State;
+    static AUTH_FAILED: State;
+    static CONNECTED_READ_ONLY: State;
+    static SASL_AUTHENTICATED: State;
+    static EXPIRED: State;
+
+    name: string;
+    code: number;
+    constructor(name: string, code: number);
+    toString(): string;
+}
+
+export class Event {
+    static NODE_CREATED: number;
+    static NODE_DELETED: number;
+    static NODE_DATA_CHANGED: number;
+    static NODE_CHILDREN_CHANGED: number;
+    type: string;
+    name: string;
+    path: string;
+    constructor(type: string, name: string, path: string);
+    toString(): string;
+    getType(): string;
+    getName(): string;
+    getPath(): string;
+}
+
+export class Transaction {
+    create(path: string, dataOrAclsOrmode1?: Buffer | ACL[] | number, dataOrAclsOrmode2?: Buffer | ACL[] | number, dataOrAclsOrmode3?: Buffer | ACL[] | number): this;
+    setData(path: string, data: Buffer | null, version?: number): this;
+    check(path: string, version?: number): this;
+    remove(path: string, version?: number): this;
+    commit(callback: (error: Error | Exception, results: any) => void): void;
+}
+
+export class Client extends EventEmitter {
+    connect(): void;
+    close(): void;
+    create(path: string, callback: (error: Error | Exception, path: string) => void): void;
+    create(path: string, dataOrAclsOrmode1: Buffer | ACL[] | number, callback: (error: Error | Exception, path: string) => void): void;
+    create(path: string, dataOrAclsOrmode1: Buffer | ACL[] | number, dataOrAclsOrmode2: Buffer | ACL[] | number, callback: (error: Error | Exception, path: string) => void): void;
+    create(path: string, dataOrAclsOrmode1: Buffer | ACL[] | number, dataOrAclsOrmode2: Buffer | ACL[] | number, dataOrAclsOrmode3: Buffer | ACL[] | number, callback: (error: Error | Exception, path: string) => void): void;
+    remove(path: string, callback: (error: Error | Exception) => void): void;
+    remove(path: string, version: number, callback: (error: Error | Exception) => void): void;
+    exists(path: string, callback: (error: Error | Exception, stat: Stat) => void): void;
+    exists(path: string, watcher: (event: Event) => void, callback: (error: Error | Exception, stat: Stat) => void): void;
+    getChildren(path: string, callback: (error: Error | Exception, children: string[], stat: Stat) => void): void;
+    getChildren(path: string, watcher: (event: Event) => void, callback: (error: Error | Exception, children: string[], stat: Stat) => void): void;
+    getData(path: string, callback: (error: Error | Exception, data: Buffer, stat: Stat) => void): void;
+    getData(path: string, watcher: (event: Event) => void, callback: (error: Error | Exception, data: Buffer, stat: Stat) => void): void;
+    setData(path: string, data: Buffer | null, callback: (error: Error | Exception, stat: Stat) => void): void;
+    setData(path: string, data: Buffer | null, version: number, callback: (error: Error | Exception, stat: Stat) => void): void;
+    getACL(path: string, callback: (error: Error | Exception, acls: ACL[], stat: Stat) => void): void;
+    setACL(path: string, acls: ACL[], callback: (error: Error | Exception, stat: Stat) => void): void;
+    setACL(path: string, acls: ACL[], version: number, callback: (error: Error | Exception, stat: Stat) => void): void;
+    transaction(): Transaction;
+    mkdirp(path: string, callback: (error: Error | Exception, path: string) => void): void;
+    mkdirp(path: string, dataOrAclsOrmode1: Buffer | ACL[] | number, callback: (error: Error | Exception, path: string) => void): void;
+    mkdirp(path: string, dataOrAclsOrmode1: Buffer | ACL[] | number, dataOrAclsOrmode2: Buffer | ACL[] | number, callback: (error: Error | Exception, path: string) => void): void;
+    mkdirp(path: string, dataOrAclsOrmode1: Buffer | ACL[] | number, dataOrAclsOrmode2: Buffer | ACL[] | number, dataOrAclsOrmode3: Buffer | ACL[] | number, callback: (error: Error | Exception, path: string) => void): void;
+    addAuthInfo(scheme: string, auth: Buffer): void;
+    getState(): State;
+    getSessionId(): Buffer;
+    getSessionPassword(): Buffer;
+    getSessionTimeout(): number;
+
+    on(event: "state", cb: (state: State) => void): this;
+    on(event: "connected" | "connectedReadOnly" | "disconnected" | "expired" | "authenticationFailed" | string, cb: () => void): this;
+
+    once(event: "state", cb: (state: State) => void): this;
+    once(event: "connected" | "connectedReadOnly" | "disconnected" | "expired" | "authenticationFailed" | string, cb: () => void): this;
+
+    addListener(event: "state", cb: (state: State) => void): this;
+    addListener(event: "connected" | "connectedReadOnly" | "disconnected" | "expired" | "authenticationFailed" | string, cb: () => void): this;
+}
+
+export interface Option {
+    sessionTimeout: number;
+    spinDelay: number;
+    retries: number;
+}
+
+export function createClient(connectionString: string, options?: Partial<Option>): Client;
+
+export const CreateMode: {
+    PERSISTENT: number,
+    PERSISTENT_SEQUENTIAL: number,
+    EPHEMERA: number,
+    EPHEMERAL_SEQUENTIAL: number,
+};
+
+export class Exception {
+    static OK: number;
+    static SYSTEM_ERROR: number;
+    static RUNTIME_INCONSISTENCY: number;
+    static DATA_INCONSISTENCY: number;
+    static CONNECTION_LOSS: number;
+    static MARSHALLING_ERROR: number;
+    static UNIMPLEMENTED: number;
+    static OPERATION_TIMEOUT: number;
+    static BAD_ARGUMENTS: number;
+    static API_ERROR: number;
+    static NO_NODE: number;
+    static NO_AUTH: number;
+    static BAD_VERSION: number;
+    static NO_CHILDREN_FOR_EPHEMERALS: number;
+    static NODE_EXISTS: number;
+    static NOT_EMPTY: number;
+    static SESSION_EXPIRED: number;
+    static INVALID_CALLBACK: number;
+    static INVALID_ACL: number;
+    static AUTH_FAILED: number;
+
+    code: number;
+    name: string;
+    path: number;
+    constructor(code: number, name: string, path: number);
+    toString(): string;
+    getCode(): number;
+    getName(): string;
+    getPath(): string;
+}
diff --git a/node-zookeeper-client/node-zookeeper-client-tests.ts b/node-zookeeper-client/node-zookeeper-client-tests.ts
new file mode 100644
index 0000000000..19cca8628b
--- /dev/null
+++ b/node-zookeeper-client/node-zookeeper-client-tests.ts
@@ -0,0 +1,253 @@
+import * as zookeeper from "node-zookeeper-client";
+
+{
+    var client = zookeeper.createClient('localhost:2181');
+    var path = process.argv[2];
+
+    client.once('connected', function () {
+        console.log('Connected to the server.');
+
+        client.create(path, function (error) {
+            if (error) {
+                console.log('Failed to create node: %s due to: %s.', path, error);
+            } else {
+                console.log('Node: %s is successfully created.', path);
+            }
+
+            client.close();
+        });
+    });
+
+    client.connect();
+}
+
+function listChildren(client: zookeeper.Client, path: string) {
+    client.getChildren(
+        path,
+        function (event) {
+            console.log('Got watcher event: %s', event);
+            listChildren(client, path);
+        },
+        function (error, children, stat) {
+            if (error) {
+                console.log(
+                    'Failed to list children of %s due to: %s.',
+                    path,
+                    error
+                );
+                return;
+            }
+
+            console.log('Children of %s are: %j.', path, children);
+        }
+    );
+}
+
+{
+    var client = zookeeper.createClient('localhost:2181');
+    var path = process.argv[2];
+
+    client.once('connected', function () {
+        console.log('Connected to ZooKeeper.');
+        listChildren(client, path);
+    });
+
+    client.connect();
+}
+
+var client = zookeeper.createClient(
+    'localhost:2181/test',
+    { sessionTimeout: 10000 }
+);
+
+{
+    client.create(
+        '/test/demo',
+        new Buffer('data'),
+        zookeeper.CreateMode.EPHEMERA,
+        function (error: Error, path) {
+            if (error) {
+                console.log(error.stack);
+                return;
+            }
+
+            console.log('Node: %s is created.', path);
+        }
+    );
+}
+
+{
+    client.remove('/test/demo', -1, function (error: Error) {
+        if (error) {
+            console.log(error.stack);
+            return;
+        }
+
+        console.log('Node is deleted.');
+    });
+}
+
+{
+    client.exists('/test/demo', function (error: Error, stat) {
+        if (error) {
+            console.log(error.stack);
+            return;
+        }
+
+        if (stat) {
+            console.log('Node exists.');
+        } else {
+            console.log('Node does not exist.');
+        }
+    });
+}
+
+{
+    client.getChildren('/test/demo', function (error: Error, children, stats) {
+        if (error) {
+            console.log(error.stack);
+            return;
+        }
+
+        console.log('Children are: %j.', children);
+    });
+}
+
+{
+    client.getData(
+        '/test/demo',
+        function (event) {
+            console.log('Got event: %s.', event);
+        },
+        function (error: Error, data, stat) {
+            if (error) {
+                console.log(error.stack);
+                return;
+            }
+
+            console.log('Got data: %s', data.toString('utf8'));
+        }
+    );
+}
+
+{
+    client.setData('/test/demo', null, 2, function (error: Error, stat) {
+        if (error) {
+            console.log(error.stack);
+            return;
+        }
+
+        console.log('Data is set.');
+    });
+}
+
+{
+    client.getACL('/test/demo', function (error: Error, acls, stat) {
+        if (error) {
+            console.log(error.stack);
+            return;
+        }
+
+        console.log('ACL(s) are: %j', acls);
+    });
+}
+
+{
+    client.setACL(
+        '/test/demo',
+        [
+            new zookeeper.ACL(
+                zookeeper.Permission.ADMIN,
+                new zookeeper.Id('ip', '127.0.0.1')
+            )
+        ],
+        function (error: Error, stat) {
+            if (error) {
+                console.log(error.stack);
+                return;
+            }
+
+            console.log('New ACL is set.');
+        }
+    );
+}
+
+{
+    client.mkdirp('/test/demo/1/2/3', function (error: Error, path) {
+        if (error) {
+            console.log(error.stack);
+            return;
+        }
+
+        console.log('Node: %s is created.', path);
+    });
+}
+
+{
+    client.addAuthInfo('ip', new Buffer('127.0.0.1'));
+}
+
+{
+    var state = client.getState();
+    console.log('Current state is: %s', state);
+}
+
+{
+    var id = client.getSessionId();
+    console.log('Session id is: %s', id.toString('hex'));
+}
+
+{
+    client.getSessionPassword();
+    client.getSessionTimeout();
+
+    client.on('connected', function () {
+        console.log('Client state is changed to connected.');
+    });
+    client.on('state', function (state) {
+        if (state === zookeeper.State.SYNC_CONNECTED) {
+            console.log('Client state is changed to connected.');
+        }
+    });
+}
+
+{
+    client.once('connected', function () {
+        client.transaction().
+            create('/txn').
+            create('/txn/1', new Buffer('transaction')).
+            setData('/txn/1', new Buffer('test'), -1).
+            check('/txn/1').
+            remove('/txn/1', -1).
+            remove('/txn').
+            commit(function (error, results) {
+                if (error) {
+                    console.log(
+                        'Failed to execute the transaction: %s, results: %j',
+                        error,
+                        results
+                    );
+
+                    return;
+                }
+
+                console.log('Transaction completed.');
+                client.close();
+            });
+    });
+}
+
+{
+    client.create('/test/demo', function (error, path) {
+        if (error) {
+            if ((error as zookeeper.Exception).getCode() == zookeeper.Exception.NODE_EXISTS) {
+                console.log('Node exists.');
+            } else {
+                console.log((error as Error).stack);
+            }
+            return;
+        }
+
+        console.log('Node: %s is created.', path);
+    });
+}
diff --git a/node-zookeeper-client/tsconfig.json b/node-zookeeper-client/tsconfig.json
new file mode 100644
index 0000000000..d93291d45b
--- /dev/null
+++ b/node-zookeeper-client/tsconfig.json
@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es5"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "node-zookeeper-client-tests.ts"
+    ]
+}
diff --git a/node-zookeeper-client/tslint.json b/node-zookeeper-client/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/node-zookeeper-client/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From df1efcebfb309e85d4d22cccec8cd42b6a9236bb Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Wed, 25 Jan 2017 14:08:40 -0800
Subject: [PATCH 30/87] Issue template: Clarify that authors should be found in
 the header

---
 ISSUE_TEMPLATE.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
index a9ae498738..252df5994f 100644
--- a/ISSUE_TEMPLATE.md
+++ b/ISSUE_TEMPLATE.md
@@ -1,5 +1,4 @@
-- [ ] I tried using the latest `xxxx/xxxx.d.ts` file in this repo and had problems.
+- [ ] I tried using the `@types/xxxx` package and had problems.
 - [ ] I tried using the latest stable version of tsc. https://www.npmjs.com/package/typescript
 - [ ] I have a question that is inappropriate for [StackOverflow](https://stackoverflow.com/).  (Please ask any appropriate questions there).
-- [ ] I want to talk about `xxxx/xxxx.d.ts`.
-  - The authors of that type definition are cc/ @....
+- The authors (see `Definitions by:` in `index.d.ts`) are cc/ @....

From 59244e309ee9dbf6de35e3c9a8454940e4d70dff Mon Sep 17 00:00:00 2001
From: york yao <yaoao12306@outlook.com>
Date: Thu, 26 Jan 2017 07:26:23 +0800
Subject: [PATCH 31/87] add typescript version

---
 node-zookeeper-client/index.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/node-zookeeper-client/index.d.ts b/node-zookeeper-client/index.d.ts
index f405aeffc7..cb9979e9f4 100644
--- a/node-zookeeper-client/index.d.ts
+++ b/node-zookeeper-client/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/alexguan/node-zookeeper-client
 // Definitions by: York Yao <https://github.com/plantain-00/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /// <reference types="node" />
 

From 2157659af755ca9ab5fc959562f5033c5d7a1398 Mon Sep 17 00:00:00 2001
From: Leonard Thieu <leonard.thieu@gmail.com>
Date: Wed, 25 Jan 2017 20:11:21 -0500
Subject: [PATCH 32/87] Add type definitions for semantic-ui.

---
 semantic-ui/index.d.ts           | 5434 ++++++++++++++++++++++++++++++
 semantic-ui/semantic-ui-tests.ts |  140 +
 semantic-ui/tsconfig.json        |   20 +
 semantic-ui/tslint.json          |    3 +
 4 files changed, 5597 insertions(+)
 create mode 100644 semantic-ui/index.d.ts
 create mode 100644 semantic-ui/semantic-ui-tests.ts
 create mode 100644 semantic-ui/tsconfig.json
 create mode 100644 semantic-ui/tslint.json

diff --git a/semantic-ui/index.d.ts b/semantic-ui/index.d.ts
new file mode 100644
index 0000000000..0c8ddda9be
--- /dev/null
+++ b/semantic-ui/index.d.ts
@@ -0,0 +1,5434 @@
+// Type definitions for Semantic UI 2.2
+// Project: http://semantic-ui.com/
+// Definitions by: Leonard Thieu <https://github.com/leonard-thieu>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="jquery" />
+
+// tslint:disable:unified-signatures
+
+interface JQuery {
+    // TODO: Do all modules have a 'setting' behavior?
+
+    // region Modules
+
+    // region Accordion
+
+    /**
+     * Refreshes all cached selectors and data
+     */
+    accordion(behavior: 'refresh'): JQuery;
+    /**
+     * Opens accordion content at index
+     */
+    accordion(behavior: 'open', index: number): JQuery;
+    /**
+     * Closes accordion content that are not active
+     */
+    accordion(behavior: 'close others'): JQuery;
+    /**
+     * Closes accordion content at index
+     */
+    accordion(behavior: 'close', index: number): JQuery;
+    /**
+     * Toggles accordion content at index
+     */
+    accordion(behavior: 'toggle', index: number): JQuery;
+    accordion(settings: SemanticUI.AccordionSettings): JQuery;
+    accordion(): JQuery;
+
+    // endregion
+
+    // region Checkbox
+
+    /**
+     * Switches a checkbox from current state
+     */
+    checkbox(behavior: 'toggle'): JQuery;
+    /**
+     * Set a checkbox state to checked
+     */
+    checkbox(behavior: 'check'): JQuery;
+    /**
+     * Set a checkbox state to unchecked
+     */
+    checkbox(behavior: 'uncheck'): JQuery;
+    /**
+     * Set as indeterminate checkbox
+     */
+    checkbox(behavior: 'indeterminate'): JQuery;
+    /**
+     * Set as determinate checkbox
+     */
+    checkbox(behavior: 'determinate'): JQuery;
+    /**
+     * Enable interaction with a checkbox
+     */
+    checkbox(behavior: 'enable'): JQuery;
+    /**
+     * Set a checkbox state to checked without callbacks
+     */
+    checkbox(behavior: 'set checked'): JQuery;
+    /**
+     * Set a checkbox state to unchecked without callbacks
+     */
+    checkbox(behavior: 'set unchecked'): JQuery;
+    /**
+     * Set as indeterminate checkbox without callbacks
+     */
+    checkbox(behavior: 'set indeterminate'): JQuery;
+    /**
+     * Set as determinate checkbox without callbacks
+     */
+    checkbox(behavior: 'set determinate'): JQuery;
+    /**
+     * Enable interaction with a checkbox without callbacks
+     */
+    checkbox(behavior: 'set enabled'): JQuery;
+    /**
+     * Disable interaction with a checkbox without callbacks
+     */
+    checkbox(behavior: 'set disabled'): JQuery;
+    /**
+     * Attach checkbox events to another element
+     */
+    checkbox(behavior: 'attach events', selector: string, event: string): JQuery;
+    /**
+     * Returns whether element is radio selection
+     */
+    checkbox(behavior: 'is radio'): boolean;
+    /**
+     * Returns whether element is currently checked
+     */
+    checkbox(behavior: 'is checked'): boolean;
+    /**
+     * Returns whether element is not checked
+     */
+    checkbox(behavior: 'is unchecked'): boolean;
+    /**
+     * Returns whether element is able to be changed
+     */
+    checkbox(behavior: 'can change'): boolean;
+    /**
+     * Returns whether element can be checked (checking if already checked or `beforeChecked` would cancel)
+     */
+    checkbox(behavior: 'should allow check'): boolean;
+    /**
+     * Returns whether element can be unchecked (checking if already unchecked or `beforeUnchecked` would cancel)
+     */
+    checkbox(behavior: 'should allow uncheck'): boolean;
+    /**
+     * Returns whether element can be determinate (checking if already determinate or `beforeDeterminate` would cancel)
+     */
+    checkbox(behavior: 'should allow determinate'): boolean;
+    /**
+     * Returns whether element can be indeterminate (checking if already indeterminate or `beforeIndeterminate` would cancel)
+     */
+    checkbox(behavior: 'should allow indeterminate'): boolean;
+    /**
+     * Returns whether element is able to be unchecked
+     */
+    checkbox(behavior: 'can uncheck'): boolean;
+    checkbox(settings: SemanticUI.CheckboxSettings): JQuery;
+    checkbox(): JQuery;
+
+    // endregion
+
+    // region Dimmer
+
+    /**
+     * Detaches a given element from DOM and reattaches element inside dimmer
+     */
+    dimmer(behavior: 'add content', element: SemanticUI.Selector): JQuery;
+    /**
+     * Shows dimmer
+     */
+    dimmer(behavior: 'show'): JQuery;
+    /**
+     * Hides dimmer
+     */
+    dimmer(behavior: 'hide'): JQuery;
+    /**
+     * Toggles current dimmer visibility
+     */
+    dimmer(behavior: 'toggle'): JQuery;
+    /**
+     * Changes dimmer opacity
+     */
+    dimmer(behavior: 'set opacity', opacity: number): JQuery;
+    /**
+     * Creates a new dimmer in dimmable context
+     */
+    dimmer(behavior: 'create'): JQuery;
+    /**
+     * Returns current duration for show or hide event depending on current visibility
+     */
+    dimmer(behavior: 'get duration'): number;
+    /**
+     * Returns DOM element for dimmer
+     */
+    dimmer(behavior: 'get dimmer'): JQuery;
+    /**
+     * Returns whether current dimmable has a dimmer
+     */
+    dimmer(behavior: 'has dimmer'): boolean;
+    /**
+     * Whether section's dimmer is active
+     */
+    dimmer(behavior: 'is active'): boolean;
+    /**
+     * Whether dimmer is animating
+     */
+    dimmer(behavior: 'is animating'): boolean;
+    /**
+     * Whether current element is a dimmer
+     */
+    dimmer(behavior: 'is dimmer'): boolean;
+    /**
+     * Whether current element is a dimmable section
+     */
+    dimmer(behavior: 'is dimmable'): boolean;
+    /**
+     * Whether dimmer is disabled
+     */
+    dimmer(behavior: 'is disabled'): boolean;
+    /**
+     * Whether dimmer is not disabled
+     */
+    dimmer(behavior: 'is enabled'): boolean;
+    /**
+     * Whether dimmable section is body
+     */
+    dimmer(behavior: 'is page'): boolean;
+    /**
+     * Whether dimmer is a page dimmer
+     */
+    dimmer(behavior: 'is page dimmer'): boolean;
+    /**
+     * Sets page dimmer to active
+     */
+    dimmer(behavior: 'set active'): JQuery;
+    /**
+     * Sets an element as a dimmable section
+     */
+    dimmer(behavior: 'set dimmable'): JQuery;
+    /**
+     * Sets a dimmable section as dimmed
+     */
+    dimmer(behavior: 'set dimmed'): JQuery;
+    /**
+     * Sets current dimmer as a page dimmer
+     */
+    dimmer(behavior: 'set page dimmer'): JQuery;
+    /**
+     * Sets a dimmer as disabled
+     */
+    dimmer(behavior: 'set disabled'): JQuery;
+    dimmer(settings: SemanticUI.DimmerSettings): JQuery;
+    dimmer(): JQuery;
+
+    // endregion
+
+    // region Dropdown
+
+    // TODO: Should 'value'/'values' parameters be of type 'string' instead of 'any'?
+
+    /**
+     * Recreates dropdown menu from select option values.
+     */
+    dropdown(behavior: 'setup menu'): JQuery;
+    /**
+     * Refreshes all cached selectors and data
+     */
+    dropdown(behavior: 'refresh'): JQuery;
+    /**
+     * Toggles current visibility of dropdown
+     */
+    dropdown(behavior: 'toggle'): JQuery;
+    /**
+     * Shows dropdown
+     */
+    dropdown(behavior: 'show'): JQuery;
+    /**
+     * Hides dropdown
+     */
+    dropdown(behavior: 'hide'): JQuery;
+    /**
+     * Clears dropdown of selection
+     */
+    dropdown(behavior: 'clear'): JQuery;
+    /**
+     * Hides all other dropdowns that is not current dropdown
+     */
+    dropdown(behavior: 'hide others'): JQuery;
+    /**
+     * Restores dropdown text and value to its value on page load
+     */
+    dropdown(behavior: 'restore defaults'): JQuery;
+    /**
+     * Restores dropdown text to its value on page load
+     */
+    dropdown(behavior: 'restore default text'): JQuery;
+    /**
+     * Restores dropdown text to its prompt, placeholder text
+     */
+    dropdown(behavior: 'restore placeholder text'): JQuery;
+    /**
+     * Restores dropdown value to its value on page load
+     */
+    dropdown(behavior: 'restore default value'): JQuery;
+    /**
+     * Saves current text and value as new defaults (for use with restore)
+     */
+    dropdown(behavior: 'save defaults'): JQuery;
+    /**
+     * Sets value as selected
+     */
+    dropdown(behavior: 'set selected', value: any): JQuery;
+    /**
+     * Remove value from selected
+     */
+    dropdown(behavior: 'remove selected', value: any): JQuery;
+    /**
+     * Adds a group of values as selected
+     */
+    dropdown(behavior: 'set selected', values: any[]): JQuery;
+    /**
+     * Sets selected values to exactly specified values, removing current selection
+     */
+    dropdown(behavior: 'set exactly', values: any[]): JQuery;
+    /**
+     * Sets dropdown text to a value
+     */
+    dropdown(behavior: 'set text', text: string): JQuery;
+    /**
+     * Sets dropdown input to value (does not update display state)
+     */
+    dropdown(behavior: 'set value', value: any): JQuery;
+    /**
+     * Returns current dropdown text
+     */
+    dropdown(behavior: 'get text'): string;
+    /**
+     * Returns current dropdown input value
+     */
+    dropdown(behavior: 'get value'): any;
+    /**
+     * Returns DOM element that matches a given input value
+     */
+    dropdown(behavior: 'get item', value: any): JQuery;
+    /**
+     * Adds touch events to element
+     */
+    dropdown(behavior: 'bind touch events'): JQuery;
+    /**
+     * Adds mouse events to element
+     */
+    dropdown(behavior: 'bind mouse events'): JQuery;
+    /**
+     * Binds a click to document to determine if you click away from a dropdown
+     */
+    dropdown(behavior: 'bind intent'): JQuery;
+    /**
+     * Unbinds document intent click
+     */
+    dropdown(behavior: 'unbind intent'): JQuery;
+    /**
+     * Returns whether event occurred inside dropdown
+     */
+    dropdown(behavior: 'determine intent'): boolean;
+    /**
+     * Triggers preset item selection action based on settings passing text/value
+     */
+    dropdown(behavior: 'determine select action', text: string, value: any): JQuery;
+    /**
+     * Sets dropdown to active state
+     */
+    dropdown(behavior: 'set active'): JQuery;
+    /**
+     * Sets dropdown to visible state
+     */
+    dropdown(behavior: 'set visible'): JQuery;
+    /**
+     * Removes dropdown active state
+     */
+    dropdown(behavior: 'remove active'): JQuery;
+    /**
+     * Removes dropdown visible state
+     */
+    dropdown(behavior: 'remove visible'): JQuery;
+    /**
+     * Returns whether dropdown is a selection dropdown
+     */
+    dropdown(behavior: 'is selection'): boolean;
+    /**
+     * Returns whether dropdown is animated
+     */
+    dropdown(behavior: 'is animated'): boolean;
+    /**
+     * Returns whether dropdown is visible
+     */
+    dropdown(behavior: 'is visible'): boolean;
+    /**
+     * Returns whether dropdown is hidden
+     */
+    dropdown(behavior: 'is hidden'): boolean;
+    /**
+     * Returns dropdown value as set on page load
+     */
+    dropdown(behavior: 'get default text'): string;
+    /**
+     * Returns placeholder text
+     */
+    dropdown(behavior: 'get placeholder text'): string;
+    dropdown(settings: SemanticUI.DropdownSettings): JQuery;
+    dropdown(): JQuery;
+
+    // endregion
+
+    // region Embed
+
+    /**
+     * Changes iframe to a new content source
+     */
+    embed(behavior: 'change', source: string, id: string, url: string): JQuery;
+    /**
+     * Removes embed and shows placeholder content if available
+     */
+    embed(behavior: 'reset'): JQuery;
+    /**
+     * Shows embed content
+     */
+    embed(behavior: 'show'): JQuery;
+    /**
+     * Hides embed content and shows placeholder content
+     */
+    embed(behavior: 'hide'): JQuery;
+    /**
+     * Returns current content id
+     */
+    embed(behavior: 'get id'): string;
+    /**
+     * Returns placeholder image url
+     */
+    embed(behavior: 'get placeholder'): string;
+    /**
+     * Returns source name
+     */
+    embed(behavior: 'get sources'): string;
+    /**
+     * Returns source type
+     */
+    embed(behavior: 'get type'): string;
+    /**
+     * Returns URL with all parameters added
+     */
+    embed(behavior: 'get url'): string;
+    /**
+     * Returns whether embed content has placeholder
+     */
+    embed(behavior: 'has placeholder'): boolean;
+    /**
+     * Destroys instance and removes all events
+     */
+    embed(behavior: 'destroy'): JQuery;
+    embed(settings: SemanticUI.EmbedSettings): JQuery;
+    embed(): JQuery;
+
+    // endregion
+
+    // region Modal
+
+    /**
+     * Shows the modal
+     */
+    modal(behavior: 'show'): JQuery;
+    /**
+     * Hides the modal
+     */
+    modal(behavior: 'hide'): JQuery;
+    /**
+     * Toggles the modal
+     */
+    modal(behavior: 'toggle'): JQuery;
+    /**
+     * Refreshes centering of modal on page
+     */
+    modal(behavior: 'refresh'): JQuery;
+    /**
+     * Shows associated page dimmer
+     */
+    modal(behavior: 'show dimmer'): JQuery;
+    /**
+     * Hides associated page dimmer
+     */
+    modal(behavior: 'hide dimmer'): JQuery;
+    /**
+     * Hides all modals not selected modal in a dimmer
+     */
+    modal(behavior: 'hide others'): JQuery;
+    /**
+     * Hides all visible modals in the same dimmer
+     */
+    modal(behavior: 'hide all'): JQuery;
+    /**
+     * Caches current modal size
+     */
+    modal(behavior: 'cache sizes'): JQuery;
+    /**
+     * Returns whether the modal can fit on the page
+     */
+    modal(behavior: 'can fit'): boolean;
+    /**
+     * Returns whether the modal is active
+     */
+    modal(behavior: 'is active'): boolean;
+    /**
+     * Sets modal to active
+     */
+    modal(behavior: 'set active'): JQuery;
+    modal(behavior: 'attach events', selector: SemanticUI.Selector, event?: string): JQuery;
+    modal(behavior: 'setting', name: string, value: any): JQuery;
+    modal(settings: SemanticUI.ModalSettings): JQuery;
+    modal(): JQuery;
+
+    // endregion
+
+    // region Nag
+
+    // TODO: Documentation is lacking. Is it possible to infer intended behaviors?
+
+    nag(behavior: 'show'): JQuery;
+    /**
+     * Clears cookie so nag shows again
+     */
+    nag(behavior: 'clear'): JQuery;
+    nag(settings: SemanticUI.NagSettings): JQuery;
+
+    // endregion
+
+    // region Popup
+
+    /**
+     * Shows popup
+     */
+    popup(behavior: 'show'): JQuery;
+    /**
+     * Hides popup
+     */
+    popup(behavior: 'hide'): JQuery;
+    /**
+     * Hides all visible pop ups on the page
+     */
+    popup(behavior: 'hide all'): JQuery;
+    /**
+     * Returns current popup dom element
+     */
+    popup(behavior: 'get popup'): JQuery;
+    /**
+     * Changes current popup content
+     */
+    popup(behavior: 'change content', html: string): JQuery;
+    /**
+     * Toggles visibility of popup
+     */
+    popup(behavior: 'toggle'): JQuery;
+    /**
+     * Returns whether popup is visible
+     */
+    popup(behavior: 'is visible'): boolean;
+    /**
+     * Returns whether popup is hidden
+     */
+    popup(behavior: 'is hidden'): boolean;
+    /**
+     * Returns whether popup is created and inserted into the page
+     */
+    popup(behavior: 'exists'): boolean;
+    /**
+     * Adjusts popup when content size changes (only necessary for centered popups)
+     */
+    popup(behavior: 'reposition'): JQuery;
+    /**
+     * Repositions a popup
+     */
+    popup(behavior: 'set position', position: string): JQuery;
+    /**
+     * Removes popup from the page and removes all events
+     */
+    popup(behavior: 'destroy'): JQuery;
+    /**
+     * Removes popup from the page
+     */
+    popup(behavior: 'remove popup'): JQuery;
+    popup(settings: SemanticUI.PopupSettings): JQuery;
+    popup(): JQuery;
+
+    // endregion
+
+    // region Progress
+
+    /**
+     * Sets current percent of progress to value. If using a total will convert from percent to estimated value.
+     */
+    progress(behavior: 'set percent', percent: number): JQuery;
+    /**
+     * Sets progress to specified value. Will automatically calculate percent from total.
+     */
+    progress(behavior: 'set progress', value: number): JQuery;
+    /**
+     * Increments progress by increment value, if not passed a value will use random amount specified in settings
+     */
+    progress(behavior: 'increment', incrementValue: number): JQuery;
+    /**
+     * Decrements progress by decrement value, if not passed a value will use random amount specified in settings
+     */
+    progress(behavior: 'decrement', decrementValue: number): JQuery;
+    /**
+     * Immediately updates progress to value, ignoring progress animation interval delays
+     */
+    progress(behavior: 'update progress', value: number): JQuery;
+    /**
+     * Finishes progress and sets loaded to 100%
+     */
+    progress(behavior: 'complete'): JQuery;
+    /**
+     * Resets progress to zero
+     */
+    progress(behavior: 'reset'): JQuery;
+    /**
+     * Set total to a new value
+     */
+    progress(behavior: 'set total', total: number): JQuery;
+    /**
+     * Replaces templated string with value, total, percent left and percent.
+     */
+    progress(behavior: 'get text', text: string): string;
+    /**
+     * Returns normalized value inside acceptable range specified by total.
+     */
+    progress(behavior: 'get normalized value', value: number): number;
+    /**
+     * Returns percent as last specified
+     */
+    progress(behavior: 'get percent'): number;
+    /**
+     * Returns current progress value
+     */
+    progress(behavior: 'get value'): number;
+    /**
+     * Returns total
+     */
+    progress(behavior: 'get total'): number;
+    /**
+     * Returns whether progress is completed
+     */
+    progress(behavior: 'is complete'): boolean;
+    /**
+     * Returns whether progress was a success
+     */
+    progress(behavior: 'is success'): boolean;
+    /**
+     * Returns whether progress is in warning state
+     */
+    progress(behavior: 'is warning'): boolean;
+    /**
+     * Returns whether progress is in error state
+     */
+    progress(behavior: 'is error'): boolean;
+    /**
+     * Returns whether progress is in active state
+     */
+    progress(behavior: 'is active'): boolean;
+    /**
+     * Sets progress to active state
+     */
+    progress(behavior: 'set active'): JQuery;
+    /**
+     * Sets progress to warning state
+     */
+    progress(behavior: 'set warning'): JQuery;
+    /**
+     * Sets progress to success state
+     */
+    progress(behavior: 'set success'): JQuery;
+    /**
+     * Sets progress to error state
+     */
+    progress(behavior: 'set error'): JQuery;
+    /**
+     * Changes progress animation speed
+     */
+    progress(behavior: 'set duration', value: number): JQuery;
+    /**
+     * Sets progress exterior label to text
+     */
+    progress(behavior: 'set label', text: string): JQuery;
+    /**
+     * Sets progress bar label to text
+     */
+    progress(behavior: 'set bar label', text: string): JQuery;
+    /**
+     * Removes progress to active state
+     */
+    progress(behavior: 'remove active'): JQuery;
+    /**
+     * Removes progress to warning state
+     */
+    progress(behavior: 'remove warning'): JQuery;
+    /**
+     * Removes progress to success state
+     */
+    progress(behavior: 'remove success'): JQuery;
+    /**
+     * Removes progress to error state
+     */
+    progress(behavior: 'remove error'): JQuery;
+    progress(settings: SemanticUI.ProgressSettings): JQuery;
+    progress(): JQuery;
+
+    // endregion
+
+    // region Rating
+
+    /**
+     * Sets rating programmatically
+     */
+    rating(behavior: 'set rating', rating: number): JQuery;
+    /**
+     * Gets current rating
+     */
+    rating(behavior: 'get rating'): number;
+    /**
+     * Disables interactive rating mode
+     */
+    rating(behavior: 'disable'): JQuery;
+    /**
+     * Enables interactive rating mode
+     */
+    rating(behavior: 'enable'): JQuery;
+    /**
+     * Clears current rating
+     */
+    rating(behavior: 'clear rating'): JQuery;
+    rating(settings: SemanticUI.RatingSettings): JQuery;
+    rating(): JQuery;
+
+    // endregion
+
+    // region Search
+
+    /**
+     * Search for value currently set in search input
+     */
+    search(behavior: 'query'): JQuery;
+    /**
+     * Displays message in search results with text, using template matching type
+     */
+    search(behavior: 'display message', text: string, type: string): JQuery;
+    /**
+     * Cancels current remote search query
+     */
+    search(behavior: 'cancel query'): JQuery;
+    /**
+     * Search local object for specified query and display results
+     */
+    search(behavior: 'search local', query: string): JQuery;
+    /**
+     * Whether has minimum characters
+     */
+    search(behavior: 'has minimum characters'): boolean;
+    /**
+     * Search remote endpoint for specified query and display results
+     */
+    search(behavior: 'search remote', query: string): JQuery;
+    /**
+     * Search object for specified query and return results
+     */
+    search(behavior: 'search object', query: string, object: any, searchFields: string[]): any;
+    /**
+     * Cancels current remote search request
+     */
+    search(behavior: 'cancel query'): JQuery;
+    /**
+     * Whether search is currently focused
+     */
+    search(behavior: 'is focused'): boolean;
+    /**
+     * Whether search results are visible
+     */
+    search(behavior: 'is visible'): boolean;
+    /**
+     * Whether search results are empty
+     */
+    search(behavior: 'is empty'): boolean;
+    /**
+     * Returns current search value
+     */
+    search(behavior: 'get value'): any;
+    /**
+     * Returns JSON object matching searched title or id (see above)
+     */
+    search(behavior: 'get result', value: any): any;
+    /**
+     * Sets search input to value
+     */
+    search(behavior: 'set value', value: any): JQuery;
+    /**
+     * Reads cached results for query
+     */
+    search(behavior: 'read cache', query: string): JQuery;
+    /**
+     * Clears value from cache, if no parameter passed clears all cache
+     */
+    search(behavior: 'clear cache', query?: string): JQuery;
+    /**
+     * Writes cached results for query
+     */
+    search(behavior: 'write cache', query: string): JQuery;
+    /**
+     * Adds HTML to results and displays
+     */
+    search(behavior: 'add results', html: string): JQuery;
+    /**
+     * Shows results container
+     */
+    search(behavior: 'show results'): JQuery;
+    /**
+     * Hides results container
+     */
+    search(behavior: 'hide results'): JQuery;
+    /**
+     * Generates results using parser specified by settings.template
+     */
+    search(behavior: 'generate results', response: any): JQuery;
+    /**
+     * Removes all events
+     */
+    search(behavior: 'destroy'): JQuery;
+    search(settings: SemanticUI.SearchSettings): JQuery;
+    search(): JQuery;
+
+    // endregion
+
+    // region Shape
+
+    /**
+     * Flips the shape upward
+     */
+    shape(behavior: 'flip up'): JQuery;
+    /**
+     * Flips the shape downward
+     */
+    shape(behavior: 'flip down'): JQuery;
+    /**
+     * Flips the shape right
+     */
+    shape(behavior: 'flip right'): JQuery;
+    /**
+     * Flips the shape left
+     */
+    shape(behavior: 'flip left'): JQuery;
+    /**
+     * Flips the shape over clock-wise
+     */
+    shape(behavior: 'flip over'): JQuery;
+    /**
+     * Flips the shape over counter-clockwise
+     */
+    shape(behavior: 'flip back'): JQuery;
+    /**
+     * Set the next side to a specific selector
+     */
+    shape(behavior: 'set next side', selector: SemanticUI.Selector): JQuery;
+    /**
+     * Returns whether shape is currently animating
+     */
+    shape(behavior: 'is animating'): boolean;
+    /**
+     * Removes all inline styles
+     */
+    shape(behavior: 'reset'): JQuery;
+    /**
+     * Queues an animation until after current animation
+     */
+    shape(behavior: 'queue', animation: string): JQuery;
+    /**
+     * Forces a reflow on element
+     */
+    shape(behavior: 'repaint'): JQuery;
+    /**
+     * Set the next side to next sibling to active element
+     */
+    shape(behavior: 'set default side'): JQuery;
+    /**
+     * Sets shape to the content size of the next side
+     */
+    shape(behavior: 'set stage size'): JQuery;
+    /**
+     * Refreshes the selector cache for element sides
+     */
+    shape(behavior: 'refresh'): JQuery;
+    /**
+     * Returns translation for next side staged below
+     */
+    shape(behavior: 'get transform down'): SemanticUI.Translation;
+    /**
+     * Returns translation for next side staged left
+     */
+    shape(behavior: 'get transform left'): SemanticUI.Translation;
+    /**
+     * Returns translation for next side staged right
+     */
+    shape(behavior: 'get transform right'): SemanticUI.Translation;
+    /**
+     * Returns translation for next side staged up
+     */
+    shape(behavior: 'get transform up'): SemanticUI.Translation;
+    /**
+     * Returns translation for next side staged down
+     */
+    shape(behavior: 'get transform down'): SemanticUI.Translation;
+    shape(settings: SemanticUI.ShapeSettings): JQuery;
+    shape(): JQuery;
+
+    // endregion
+
+    // region Sidebar
+
+    /**
+     * Attaches sidebar action to given selector. Default event if none specified is toggle
+     */
+    sidebar(behavior: 'attach events', selector: string, event?: string): JQuery;
+    /**
+     * Shows sidebar
+     */
+    sidebar(behavior: 'show'): JQuery;
+    /**
+     * Hides sidebar
+     */
+    sidebar(behavior: 'hide'): JQuery;
+    /**
+     * Toggles visibility of sidebar
+     */
+    sidebar(behavior: 'toggle'): JQuery;
+    /**
+     * Returns whether sidebar is visible
+     */
+    sidebar(behavior: 'is visible'): boolean;
+    /**
+     * Returns whether sidebar is hidden
+     */
+    sidebar(behavior: 'is hidden'): boolean;
+    /**
+     * Pushes page content to be visible alongside sidebar
+     */
+    sidebar(behavior: 'push page'): JQuery;
+    /**
+     * Returns direction of current sidebar
+     */
+    sidebar(behavior: 'get direction'): string;
+    /**
+     * Returns page content to original position
+     */
+    sidebar(behavior: 'pull page'): JQuery;
+    /**
+     * Adds stylesheet to page head to trigger sidebar animations
+     */
+    sidebar(behavior: 'add body CSS'): JQuery;
+    /**
+     * Removes any inline stylesheets for sidebar animation
+     */
+    sidebar(behavior: 'remove body CSS'): JQuery;
+    /**
+     * Returns vendor prefixed transition end event
+     */
+    sidebar(behavior: 'get transition event'): string;
+    sidebar(settings: SemanticUI.SidebarSettings): JQuery;
+    sidebar(): JQuery;
+
+    // endregion
+
+    // region Sticky
+
+    /**
+     * recalculates offsets
+     */
+    sticky(behavior: 'refresh'): JQuery;
+    sticky(settings: SemanticUI.StickySettings): JQuery;
+    sticky(): JQuery;
+
+    // endregion
+
+    // region Tab
+
+    /**
+     * Attaches tab action to given selector. Default event if none specified is toggle
+     */
+    tab(behavior: 'attach events', selector: string, event?: string): JQuery;
+    /**
+     * Changes tab to path
+     */
+    tab(behavior: 'change tab', path: string): JQuery;
+    /**
+     * Sets current path to state
+     */
+    tab(behavior: 'set state', path: string): JQuery;
+    /**
+     * Returns current path
+     */
+    tab(behavior: 'get path'): string;
+    /**
+     * Returns whether tab exists
+     */
+    tab(behavior: 'is tab'): boolean;
+    /**
+     * Returns cached HTML for path
+     */
+    tab(behavior: 'cache read', path: string): string | false;
+    /**
+     * Sets cached HTML for path
+     */
+    tab(behavior: 'cache add', path: string, html: string): JQuery;
+    /**
+     * Removes cached HTML for path
+     */
+    tab(behavior: 'cache remove', path: string): JQuery;
+    tab(settings: SemanticUI.TabSettings): JQuery;
+    tab(): JQuery;
+
+    // endregion
+
+    // region Transition
+
+    /**
+     * Stop current animation and preserve queue
+     */
+    transition(behavior: 'stop'): JQuery;
+    /**
+     * Stop current animation and queued animations
+     */
+    transition(behavior: 'stop all'): JQuery;
+    /**
+     * Clears all queued animations
+     */
+    transition(behavior: 'clear queue'): JQuery;
+    /**
+     * Stop current animation and show element
+     */
+    transition(behavior: 'show'): JQuery;
+    /**
+     * Stop current animation and hide element
+     */
+    transition(behavior: 'hide'): JQuery;
+    /**
+     * Toggles between hide and show
+     */
+    transition(behavior: 'toggle'): JQuery;
+    /**
+     * Forces reflow using a more expensive but stable method
+     */
+    transition(behavior: 'force repaint'): JQuery;
+    /**
+     * Triggers reflow on element
+     */
+    transition(behavior: 'repaint'): JQuery;
+    /**
+     * Resets all conditions changes during transition
+     */
+    transition(behavior: 'reset'): JQuery;
+    /**
+     * Enables animation looping
+     */
+    transition(behavior: 'looping'): JQuery;
+    /**
+     * Removes looping state from element
+     */
+    transition(behavior: 'remove looping'): JQuery;
+    /**
+     * Adds disabled state (stops ability to animate)
+     */
+    transition(behavior: 'disable'): JQuery;
+    /**
+     * Removes disabled state
+     */
+    transition(behavior: 'enable'): JQuery;
+    /**
+     * Modifies element animation duration
+     */
+    transition(behavior: 'set duration', duration: number): JQuery;
+    /**
+     * Saves all class names and styles to cache to be retrieved after animation
+     */
+    transition(behavior: 'save conditions'): JQuery;
+    /**
+     * Adds back cached names and styles to element
+     */
+    transition(behavior: 'restore conditions'): JQuery;
+    /**
+     * Returns vendor prefixed animation property for animationname
+     */
+    transition(behavior: 'get animation name'): string;
+    /**
+     * Returns vendor prefixed animation property for animationend
+     */
+    transition(behavior: 'get animation event'): string;
+    /**
+     * Returns whether element is currently visible
+     */
+    transition(behavior: 'is visible'): boolean;
+    /**
+     * Returns whether transition is currently occurring
+     */
+    transition(behavior: 'is animating'): boolean;
+    /**
+     * Returns whether animation looping is set
+     */
+    transition(behavior: 'is looping'): boolean;
+    /**
+     * Returns whether animations are supported
+     */
+    transition(behavior: 'is supported'): boolean;
+    transition(transition: string): JQuery;
+    transition(settings: SemanticUI.TransitionSettings): JQuery;
+    transition(): JQuery;
+
+    // endregion
+
+    // endregion
+
+    // region Behaviors
+
+    // region API
+
+    /**
+     * Execute query using existing API settings
+     */
+    api(behavior: 'query'): JQuery;
+    /**
+     * Adds data to existing templated url and returns full url string
+     */
+    api(behavior: 'add url data', url: string, data: any): string;
+    /**
+     * Gets promise for current API request
+     */
+    api(behavior: 'get request'): JQueryDeferred<any> | false;
+    /**
+     * Aborts current API request
+     */
+    api(behavior: 'abort'): JQuery;
+    /**
+     * Removes loading and error state from element
+     */
+    api(behavior: 'reset'): JQuery;
+    /**
+     * Returns whether last request was cancelled
+     */
+    api(behavior: 'was cancelled'): boolean;
+    /**
+     * Returns whether last request was failure
+     */
+    api(behavior: 'was failure'): boolean;
+    /**
+     * Returns whether last request was successful
+     */
+    api(behavior: 'was successful'): boolean;
+    /**
+     * Returns whether last request was completed
+     */
+    api(behavior: 'was complete'): boolean;
+    /**
+     * Returns whether element is disabled
+     */
+    api(behavior: 'is disabled'): boolean;
+    /**
+     * Returns whether element response is mocked
+     */
+    api(behavior: 'is mocked'): boolean;
+    /**
+     * Returns whether element is loading
+     */
+    api(behavior: 'is loading'): boolean;
+    /**
+     * Sets loading state to element
+     */
+    api(behavior: 'set loading'): JQuery;
+    /**
+     * Sets error state to element
+     */
+    api(behavior: 'set error'): JQuery;
+    /**
+     * Removes loading state to element
+     */
+    api(behavior: 'remove loading'): JQuery;
+    /**
+     * Removes error state to element
+     */
+    api(behavior: 'remove error'): JQuery;
+    /**
+     * Gets event that API request will occur on
+     */
+    api(behavior: 'get event'): string;
+    /**
+     * Returns encodeURIComponent value only if value passed is not already encoded
+     */
+    api(behavior: 'get url encoded value', value: any): string;
+    /**
+     * Reads a locally cached response for a URL
+     */
+    api(behavior: 'read cached response', url: string): any;
+    /**
+     * Writes a cached response for a URL
+     */
+    api(behavior: 'write cached response', url: string, response: any): JQuery;
+    /**
+     * Creates new cache, removing all locally cached URLs
+     */
+    api(behavior: 'create cache'): JQuery;
+    /**
+     * Removes API settings from the page and all events
+     */
+    api(behavior: 'destroy'): JQuery;
+    api(settings: SemanticUI.ApiSettings): JQuery;
+    api(): JQuery;
+
+    // endregion
+
+    // region Form Validation
+
+    /**
+     * Submits selected form
+     */
+    form(behavior: 'submit'): JQuery;
+    /**
+     * Returns true/false whether a form passes its validation rules
+     */
+    form(behavior: 'is valid'): boolean;
+    /**
+     * Validates form and calls onSuccess or onFailure
+     */
+    form(behavior: 'validate form'): JQuery;
+    /**
+     * gets browser property change event
+     */
+    form(behavior: 'get change event'): string;
+    /**
+     * Returns element with matching name, id, or data-validate metadata to ID
+     */
+    form(behavior: 'get field', id: string): JQuery;
+    /**
+     * Returns value of element with id
+     */
+    form(behavior: 'get value', id: string): any;
+    /**
+     * Returns object of element values that match array of ids. If no IDS are passed will return all fields
+     */
+    form(behavior: 'get values', ids?: string[]): any;
+    /**
+     * Sets value of element with id
+     */
+    form(behavior: 'set value', id: string): JQuery;
+    /**
+     * Sets key/value pairs from passed values object to matching ids
+     */
+    form(behavior: 'set values', values: any): JQuery;
+    /**
+     * Returns validation rules for a given jQuery-referenced input field
+     */
+    form(behavior: 'get validation', element: JQuery): any;
+    /**
+     * Returns whether a field exists
+     */
+    form(behavior: 'has field', identifier: string): boolean;
+    /**
+     * Adds errors to form, given an array errors
+     */
+    form(behavior: 'add errors', errors: string[]): JQuery;
+    form(settings: SemanticUI.FormSettings): JQuery;
+    form(): JQuery;
+
+    // endregion
+
+    // region Visibility
+
+    /**
+     * Disable callbacks temporarily. This is useful if you need to adjust scroll position and do not want to trigger callbacks during the position change.
+     */
+    visibility(behavior: 'disable callbacks'): JQuery;
+    /**
+     * Re-enable callbacks
+     */
+    visibility(behavior: 'enable callbacks'): JQuery;
+    /**
+     * Returns whether element is on screen
+     */
+    visibility(behavior: 'is on screen'): boolean;
+    /**
+     * Returns whether element is off screen
+     */
+    visibility(behavior: 'is off screen'): boolean;
+    /**
+     * Returns number of pixels passed in current element from top of element
+     */
+    visibility(behavior: 'get pixels passed'): number;
+    /**
+     * Returns element calculations as object
+     */
+    visibility(behavior: 'get element calculations'): SemanticUI.ElementCalculations;
+    /**
+     * Returns screen calculations as object
+     */
+    visibility(behavior: 'get screen calculations'): SemanticUI.ScreenCalculations;
+    /**
+     * Returns screen size as object
+     */
+    visibility(behavior: 'get screen size'): SemanticUI.ScreenSize;
+    visibility(settings: SemanticUI.VisibilitySettings): JQuery;
+    visibility(): JQuery;
+
+    // endregion
+
+    // endregion
+}
+
+declare namespace SemanticUI {
+    type Selector = string | JQuery;
+
+    /**
+     * These settings are native to all modules, and define how the component ties content to DOM attributes, and debugging settings for the module.
+     */
+    interface ComponentSettings {
+        // region DOM Settings
+
+        /**
+         * Event namespace. Makes sure module teardown does not effect other events attached to an element.
+         */
+            namespace?: string;
+
+        // endregion
+
+        // region Debug Settings
+
+        /**
+         * Name used in log statements
+         */
+        name?: string;
+        /**
+         * Silences all console output including error messages, regardless of other debug settings.
+         */
+        silent?: boolean;
+        /**
+         * Debug output to console
+         */
+        debug?: boolean;
+        /**
+         * Show console.table output with performance metrics
+         */
+        performance?: boolean;
+        /**
+         * Debug output includes all internal behaviors
+         */
+        verbose?: boolean;
+
+        // endregion
+    }
+
+    // region Modules
+
+    // region Accordion
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/accordion.html#/settings}
+     */
+    interface AccordionSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * Only allow one section open at a time
+         *
+         * @default true
+         */
+        exclusive?: boolean;
+        /**
+         * Event on title that will cause accordion to open
+         *
+         * @default 'click'
+         */
+        on?: string;
+        /**
+         * Whether child content opacity should be animated (may cause performance issues with many child elements)
+         *
+         * @default true
+         */
+        animateChildren?: boolean;
+        /**
+         * Close open nested accordion content when an element closes
+         *
+         * @default true
+         */
+        closeNested?: boolean;
+        /**
+         * Allow active sections to collapse
+         *
+         * @default true
+         */
+        collapsible?: boolean;
+        /**
+         * Duration in ms of opening animation
+         *
+         * @default 500
+         */
+        duration?: number;
+        /**
+         * Easing of opening animation. EaseInOutQuint is included with accordion, for additional options you must include easing equations.
+         *
+         * @default 'easeInOutQuint'
+         * @see {@link http://gsgd.co.uk/sandbox/jquery/easing/}
+         */
+        easing?: string;
+        // TODO: Undocumented but probably intended to be public?
+        // observeChanges?: boolean;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback before element opens
+         */
+        onOpening?: (this: JQuery) => void;
+        /**
+         * Callback after element is open
+         */
+        onOpen?: (this: JQuery) => void;
+        /**
+         * Callback before element closes
+         */
+        onClosing?: (this: JQuery) => void;
+        /**
+         * Callback after element is closed
+         */
+        onClose?: (this: JQuery) => void;
+        /**
+         * Callback on element open or close
+         */
+        onChange?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Selectors used to find parts of a module
+         */
+        selector?: {
+            /**
+             * @default '.accordion'
+             */
+            accordion?: string;
+            /**
+             * @default '.title'
+             */
+            title?: string;
+            /**
+             * @default '.title'
+             */
+            trigger?: string;
+            /**
+             * @default '.content'
+             */
+            content?: string;
+        };
+        /**
+         * Class names used to determine element state
+         */
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'animating'
+             */
+            animating?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Checkbox
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/checkbox.html#/settings}
+     */
+    interface CheckboxSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * Setting to true/false will determine whether an input will allow no selection. Auto will set disallow this behavior only for radio boxes
+         *
+         * @default 'auto'
+         */
+        uncheckable?: 'auto' | boolean;
+        /**
+         * Whether callbacks for checked status should be fired on init as well as change
+         *
+         * @default false
+         */
+        fireOnInit?: boolean;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback after a checkbox is either checked or unchecked.
+         */
+        onChange?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is checked.
+         */
+        onChecked?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is set to undeterminate.
+         */
+        onIndeterminate?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is set to determinate.
+         */
+        onDeterminate?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is unchecked.
+         */
+        onUnchecked?: (this: HTMLElement) => void;
+        /**
+         * Callback before a checkbox is checked. Can cancel change by returning false
+         */
+        beforeChecked?: (this: HTMLElement) => boolean;
+        /**
+         * Callback before a checkbox is set to undeterminate. Can cancel change by returning false
+         */
+        beforeIndeterminate?: (this: HTMLElement) => boolean;
+        /**
+         * Callback before a checkbox is set to determinate. Can cancel change by returning false
+         */
+        beforeDeterminate?: (this: HTMLElement) => boolean;
+        /**
+         * Callback before a checkbox is unchecked. Can cancel change by returning false
+         */
+        beforeUnchecked?: (this: HTMLElement) => boolean;
+        /**
+         * Callback after a checkbox is enabled.
+         */
+        onEnable?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is disabled.
+         */
+        onDisable?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is enabled.
+         *
+         * @deprecated
+         */
+        onEnabled?: (this: HTMLElement) => void;
+        /**
+         * Callback after a checkbox is disabled.
+         *
+         * @deprecated
+         */
+        onDisabled?: (this: HTMLElement) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Selectors used to find parts of a module
+         */
+        selector?: {
+            /**
+             * @default 'input[type=checkbox], input[type=radio]'
+             */
+            input?: string;
+            /**
+             * @default 'label'
+             */
+            label?: string;
+        };
+        /**
+         * Class names used to determine element state
+         */
+        className?: {
+            /**
+             * @default 'checked'
+             */
+            checked?: string;
+            /**
+             * @default 'disabled'
+             */
+            disabled?: string;
+            /**
+             * @default 'radio'
+             */
+            radio?: string;
+            /**
+             * @default 'read-only'
+             */
+            readOnly?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Dimmer
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/dimmer.html#/settings}
+     */
+    interface DimmerSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * Dimmers opacity from 0-1. Defaults to auto which uses the CSS specified opacity.
+         *
+         * @default 'auto'
+         */
+        opacity?: 'auto' | number;
+        /**
+         * Specify a variation to add when generating dimmer, like inverted
+         *
+         * @default false
+         */
+        variation?: false | string;
+        /**
+         * If initializing a dimmer on a dimmable context, you can use dimmerName to distinguish between multiple dimmers in that context.
+         *
+         * @default false
+         */
+        dimmerName?: false | string;
+        /**
+         * Whether clicking on the dimmer should hide the dimmer (Defaults to auto, closable only when settings.on is not hover
+         *
+         * @default 'auto'
+         */
+        closable?: 'auto' | boolean;
+        /**
+         * Can be set to hover or click to show/hide dimmer on dimmable event
+         *
+         * @default false
+         */
+        on?: false | 'hover' | 'click';
+        /**
+         * Whether to dim dimmers using CSS transitions.
+         *
+         * @default true
+         */
+        useCSS?: boolean;
+        /**
+         * Animation duration of dimming. If an integer is used, that value will apply to both show and hide animations.
+         */
+        duration?: number | {
+            /**
+             * @default 500
+             */
+            show?: number;
+            /**
+             * @default 500
+             */
+            hide?: number;
+        };
+        /**
+         * Named transition to use when animating menu in and out. Fade and slide down are available without including ui transitions
+         *
+         * @default 'fade'
+         * @see {@link http://semantic-ui.com/modules/transition.html}
+         */
+        transition?: string;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback on element show
+         */
+        onShow?: (this: JQuery) => void;
+        /**
+         * Callback on element hide
+         */
+        onHide?: (this: JQuery) => void;
+        /**
+         * Callback on element show or hide
+         */
+        onchange?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Object containing selectors used by module.
+         */
+        selector?: {
+            /**
+             * @default '.dimmable'
+             */
+            dimmable?: string;
+            /**
+             * @default '.ui.dimmer'
+             */
+            dimmer?: string;
+            /**
+             * @default '.ui.dimmer > .content, .ui.dimmer > .content > .center'
+             */
+            content?: string;
+        };
+        /**
+         * Templates used to generate dimmer content
+         */
+        template?: {
+            dimmer?: () => JQuery;
+        };
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'dimmable'
+             */
+            dimmable?: string;
+            /**
+             * @default 'dimmed'
+             */
+            dimmed?: string;
+            /**
+             * @default 'disabled'
+             */
+            disabled?: string;
+            /**
+             * @default 'page'
+             */
+            pageDimmer?: string;
+            /**
+             * @default 'hide'
+             */
+            hide?: string;
+            /**
+             * @default 'show'
+             */
+            show?: string;
+            /**
+             * @default 'transition'
+             */
+            transition?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        /**
+         * Error messages displayed to console
+         */
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Dropdown
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/dropdown.html#/settings}
+     */
+    interface DropdownSettings extends ComponentSettings {
+        // TODO: Should 'value'/'values' parameters be of type 'string' instead of 'any'?
+
+        // region Frequently Used Settings
+
+        /**
+         * Event used to trigger dropdown (Hover, Click, Custom Event)
+         *
+         * @default 'click'
+         */
+        on?: string;
+        /**
+         * When set to true will fire onChange even when the value a user select matches the currently selected value.
+         *
+         * @default false
+         */
+        allowReselection?: boolean;
+        /**
+         * Whether search selection should allow users to add their own selections, works for single or multi-select.
+         *
+         * @default false
+         */
+        allowAdditions?: boolean;
+        /**
+         * When disabled user additions will appear in the results menu using a specially formatted selection item formatted by templates.addition.
+         *
+         * @default true
+         */
+        hideAdditions?: boolean;
+        /**
+         * Sets a default action to occur. (See usage guide)
+         *
+         * @default 'activate'
+         * @see {@link http://semantic-ui.com/modules/dropdown.html#/usage}
+         */
+        action?: 'activate' | 'select' | 'combo' | 'nothing' | 'hide' | ((this: JQuery, text: string, value: string | false, element: JQuery) => void);
+        /**
+         * The minimum characters for a search to begin showing results
+         *
+         * @default 1
+         */
+        minCharacters?: number;
+        /**
+         * When using search selection specifies how to match values.
+         *
+         * @default 'both'
+         */
+        match?: 'both' | 'value' | 'text';
+        /**
+         * Whether dropdown should select new option when using keyboard shortcuts. Setting to false will require enter or left click to confirm a choice.
+         *
+         * @default true
+         */
+        selectOnKeydown?: boolean;
+        /**
+         * Whether search selection will force currently selected choice when element is blurred.
+         *
+         * @default true
+         */
+        forceSelection?: boolean;
+        /**
+         * Whether menu items with sub-menus (categories) should be selectable
+         *
+         * @default false
+         */
+        allowCategorySelection?: boolean;
+        /**
+         * @default 'auto'
+         */
+        placeholder?: 'auto' | 'value' | false;
+
+        // endregion
+
+        // region Remote Settings
+
+        /**
+         * Can be set to an object to specify API settings for retrieving remote selection menu content from an API endpoint
+         *
+         * @default false
+         * @see {@link http://semantic-ui.com/behaviors/api.html}
+         */
+        apiSettings?: false | ApiSettings;
+        /**
+         * List mapping dropdown content to JSON Property when using API
+         */
+        fields?: {
+            /**
+             * grouping for api results
+             *
+             * @default 'results'
+             */
+            remoteValues?: string;
+            /**
+             * grouping for all dropdown values
+             *
+             * @default 'values'
+             */
+            values?: string;
+            /**
+             * displayed dropdown text
+             *
+             * @default 'name'
+             */
+            name?: string;
+            /**
+             * actual dropdown value
+             *
+             * @default 'value'
+             */
+            value?: string;
+        };
+        /**
+         * When enabled will automatically store selected name/value pairs in sessionStorage to preserve user selection on page refresh. Disabling will clear remote dropdown values on refresh.
+         *
+         * @default true
+         */
+        saveRemoteData?: boolean;
+
+        // endregion
+
+        // region Multiple Select Settings
+
+        /**
+         * Whether multiselect should use labels. Must be set to true when allowAdditions is true
+         *
+         * @default true
+         */
+        useLabels?: boolean;
+        /**
+         * When set to a number, sets the maximum number of selections
+         *
+         * @default false
+         */
+        maxSelections?: boolean;
+        /**
+         * Maximum glyph width, used to calculate search size. This is usually size of a "W" in your font in em
+         *
+         * @default 1.0714
+         */
+        glyphWidth?: number;
+        /**
+         * Allows customization of multi-select labels
+         */
+        label?: {
+            /**
+             * @default 'horizontal flip'
+             */
+            transition?: string;
+            /**
+             * @default 200
+             */
+            duration?: number;
+            /**
+             * @default false
+             */
+            variation?: false | string;
+        };
+
+        // endregion
+
+        // region Additional Settings
+
+        /**
+         * When set to auto determines direction based on whether dropdown can fit on screen. Set to upward or downward to always force a direction.
+         *
+         * @default 'auto'
+         */
+        direction?: 'auto' | 'upward' | 'downward';
+        /**
+         * Whether dropdown should try to keep itself on screen by checking whether menus display position in its context (Default context is page).
+         *
+         * @default true
+         */
+        keepOnScreen?: boolean;
+        /**
+         * Element context to use when checking whether can show when keepOnScreen: true
+         *
+         * @default 'window'
+         */
+        context?: Selector;
+        /**
+         * Specifying to "true" will use a fuzzy full text search, setting to "exact" will force the exact search to be matched somewhere in the string
+         *
+         * @default false
+         */
+        fullTextSearch?: boolean | 'exact';
+        /**
+         * Whether HTML included in dropdown values should be preserved. (Allows icons to show up in selected value)
+         *
+         * @default true
+         */
+        preserveHTML?: boolean;
+        /**
+         * Whether to sort values when creating a dropdown automatically from a select element.
+         *
+         * @default false
+         */
+        sortSelect?: boolean;
+        /**
+         * Whether to show dropdown menu automatically on element focus.
+         *
+         * @default true
+         */
+        showOnFocus?: boolean;
+        /**
+         * Whether to allow the element to be navigable by keyboard, by automatically creating a tabindex
+         *
+         * @default true
+         */
+        allowTab?: boolean;
+        /**
+         * Named transition to use when animating menu in and out. Defaults to slide down or slide up depending on dropdown direction. Fade and slide down are available without including ui transitions
+         *
+         * @default 'auto'
+         * @see {@link http://semantic-ui.com/modules/transition.html}
+         */
+        transition?: 'auto' | string;
+        /**
+         * Duration of animation events
+         *
+         * @default 200
+         */
+        duration?: number;
+        /**
+         * The keycode used to represent keyboard shortcuts. To avoid issues with some foreign languages, you can pass false for comma delimiter's value
+         */
+        keys?: {
+            /**
+             * @default 8
+             */
+            backspace?: number;
+            /**
+             * @default 188
+             */
+            delimiter?: number | false;
+            /**
+             * @default 46
+             */
+            deleteKey?: number;
+            /**
+             * @default 13
+             */
+            enter?: number;
+            /**
+             * @default 27
+             */
+            escape?: number;
+            /**
+             * @default 33
+             */
+            pageUp?: number;
+            /**
+             * @default 34
+             */
+            pageDown?: number;
+            /**
+             * @default 37
+             */
+            leftArrow?: number;
+            /**
+             * @default 38
+             */
+            upArrow?: number;
+            /**
+             * @default 39
+             */
+            rightArrow?: number;
+            /**
+             * @default 40
+             */
+            downArrow?: number;
+        };
+        /**
+         * Time in milliseconds to debounce show or hide behavior when on: hover is used, or when touch is used.
+         */
+        delay?: {
+            /**
+             * @default 300
+             */
+            hide?: number;
+            /**
+             * @default 200
+             */
+            show?: number;
+            /**
+             * @default 50
+             */
+            search?: number;
+            /**
+             * @default 50
+             */
+            touch?: number;
+        };
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Is called after a dropdown value changes. Receives the name and value of selection and the active menu element
+         */
+        onChange?: (this: JQuery, value: any, text: string, $choice: JQuery) => void;
+        /**
+         * Is called after a dropdown selection is added using a multiple select dropdown, only receives the added value
+         */
+        onAdd?: (this: JQuery, addedValue: any, addedText: string, $addedChoice: JQuery) => void;
+        /**
+         * Is called after a dropdown selection is removed using a multiple select dropdown, only receives the removed value
+         */
+        onRemove?: (this: JQuery, removedValue: any, removedText: string, $removedChoice: JQuery) => void;
+        /**
+         * Allows you to modify a label before it is added. Expects the jQ DOM element for a label to be returned.
+         */
+        onLabelCreate?: (this: JQuery, value: any, text: string) => JQuery;
+        /**
+         * Called when a label is remove, return false; will prevent the label from being removed.
+         */
+        onLabelRemove?: (this: JQuery, value: any) => false | void;
+        /**
+         * Is called after a label is selected by a user
+         */
+        onLabelSelect?: (this: JQuery, $selectedLabels: JQuery) => void;
+        /**
+         * Is called after a dropdown is searched with no matching values
+         */
+        onNoResults?: (this: JQuery, searchValue: any) => void;
+        /**
+         * Is called before a dropdown is shown. If false is returned, dropdown will not be shown.
+         */
+        onShow?: (this: JQuery) => false | void;
+        /**
+         * Is called before a dropdown is hidden. If false is returned, dropdown will not be hidden.
+         */
+        onHide?: (this: JQuery) => false | void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * You can specify site wide messages by modifying $.fn.dropdown.settings.message that will apply on any dropdown if it appears in the page.
+         */
+        message?: {
+            /**
+             * @default 'Add <b>{term}</b>'
+             */
+            addResult?: string;
+            /**
+             * @default '{count} selected'
+             */
+            count?: string;
+            /**
+             * @default 'Max {maxCount} selections'
+             */
+            maxSelections?: string;
+            /**
+             * 'No results found.'
+             */
+            noResults?: string;
+        };
+        selector?: {
+            /**
+             * @default '.addition'
+             */
+            addition?: string;
+            /**
+             * @default '.ui.dropdown'
+             */
+            dropdown?: string;
+            /**
+             * @default '> .dropdown.icon'
+             */
+            icon?: string;
+            /**
+             * @default '> input[type="hidden"], > select'
+             */
+            input?: string;
+            /**
+             * @default '.item'
+             */
+            item?: string;
+            /**
+             * @default '> .label'
+             */
+            label?: string;
+            /**
+             * @default '> .label > .delete.icon'
+             */
+            remove?: string;
+            /**
+             * @default '.label'
+             */
+            siblingLabel?: string;
+            /**
+             * @default '.menu'
+             */
+            menu?: string;
+            /**
+             * @default '.message'
+             */
+            message?: string;
+            /**
+             * @default '.dropdown.icon'
+             */
+            menuIcon?: string;
+            /**
+             * @default 'input.search, .menu > .search > input'
+             */
+            search?: string;
+            /**
+             * @default '> .text:not(.icon)'
+             */
+            text?: string;
+        };
+        regExp?: {
+            /**
+             * @default /[-[\]{}()*+?.,\\^$|#\s]/g
+             */
+            escape?: RegExp;
+        };
+        metadata?: {
+            /**
+             * @default 'defaultText'
+             */
+            defaultText?: string;
+            /**
+             * @default 'defaultValue'
+             */
+            defaultValue?: string;
+            /**
+             * @default 'placeholderText'
+             */
+            placeholderText?: string;
+            /**
+             * @default 'text'
+             */
+            text?: string;
+            /**
+             * @default 'value'
+             */
+            value?: string;
+        };
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'addition'
+             */
+            addition?: string;
+            /**
+             * @default 'animating'
+             */
+            animating?: string;
+            /**
+             * @default 'disabled'
+             */
+            disabled?: string;
+            /**
+             * @default 'ui dropdown'
+             */
+            dropdown?: string;
+            /**
+             * @default 'filtered'
+             */
+            filtered?: string;
+            /**
+             * @default 'hidden transition'
+             */
+            hidden?: string;
+            /**
+             * @default 'item'
+             */
+            item?: string;
+            /**
+             * @default 'ui label'
+             */
+            label?: string;
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'menu'
+             */
+            menu?: string;
+            /**
+             * @default 'message'
+             */
+            message?: string;
+            /**
+             * @default 'multiple'
+             */
+            multiple?: string;
+            /**
+             * @default 'default'
+             */
+            placeholder?: string;
+            /**
+             * @default 'search'
+             */
+            search?: string;
+            /**
+             * @default 'selected'
+             */
+            selected?: string;
+            /**
+             * @default 'selection'
+             */
+            selection?: string;
+            /**
+             * @default 'upward'
+             */
+            upward?: string;
+            /**
+             * @default 'visible'
+             */
+            visible?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'You called a dropdown action that was not defined'
+             */
+            action?: string;
+            /**
+             * @default 'Once a select has been initialized behaviors must be called on the created ui dropdown'
+             */
+            alreadySetup?: string;
+            /**
+             * @default 'Allowing user additions currently requires the use of labels.'
+             */
+            labels?: string;
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+            /**
+             * @default 'This module requires ui transitions <https: github.com="" semantic-org="" ui-transition="">'
+             */
+            noTransition?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Embed
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/embed.html#/settings}
+     */
+    interface EmbedSettings extends ComponentSettings {
+        /**
+         * Specifies a url to use for embed
+         *
+         * @default false
+         */
+        url?: false | string;
+
+        // region Embed Settings
+
+        /**
+         * Specifies an icon to use with placeholder content
+         *
+         * @default false
+         */
+        icon?: false | string;
+        /**
+         * Specifies a source to use, if no source is provided it will be determined from the domain of a specified url.
+         *
+         * @default false
+         */
+        source?: false | string;
+        /**
+         * Specifies an id value to replace with the {id} value found in templated urls
+         *
+         * @default false
+         */
+        id?: false | string;
+        /**
+         * Specify an object containing key/value pairs to add to the iframes GET parameters
+         *
+         * @default false
+         */
+        parameters?: false | any;
+
+        // endregion
+
+        // region Video Settings
+
+        /**
+         * Default setting auto will only autoplay content when a placeholder is specified. Setting to true or false will force autoplay.
+         *
+         * @default 'auto'
+         */
+        autoplay?: 'auto' | boolean;
+        /**
+         * Specifies a default chrome color with Vimeo or YouTube.
+         *
+         * @default '#444444'
+         */
+        color?: string;
+        /**
+         * Whether to prefer HD content
+         *
+         * @default true
+         */
+        hd?: boolean;
+        /**
+         * Whether to show networks branded UI like title cards, or after video calls to action.
+         *
+         * @default false
+         */
+        brandedUI?: boolean;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback when iframe is generated
+         */
+        onCreate?: (this: JQuery, url: string) => void;
+        /**
+         * Whenever an iframe contents is shown
+         */
+        onDisplay?: (this: JQuery) => void;
+        /**
+         * Callback immediately before Embed is removed from DOM
+         */
+        onPlaceholderDisplay?: (this: JQuery) => void;
+        /**
+         * Callback when module parameters are determined. Allows you to adjust parameters at run time by returning a new parameters object.
+         */
+        onEmbed?: (this: JQuery, parameters: any) => any;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * DOM Selectors used internally
+         */
+        selector?: {
+            /**
+             * @default '.embed'
+             */
+            embed?: string;
+            /**
+             * @default '.placeholder'
+             */
+            placeholder?: string;
+            /**
+             * @default '.play'
+             */
+            play?: string;
+        };
+        /**
+         * HTML Data attributes used to store data
+         */
+        metadata?: {
+            /**
+             * @default 'id'
+             */
+            id?: string;
+            /**
+             * @default 'icon'
+             */
+            icon?: string;
+            /**
+             * @default 'placeholder'
+             */
+            placeholder?: string;
+            /**
+             * @default 'source'
+             */
+            source?: string;
+            /**
+             * @default 'url'
+             */
+            url?: string;
+        };
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'embed'
+             */
+            embed?: string;
+        };
+        templates?: {
+            /**
+             * returns html for iframe
+             */
+            iframe?: (url: string, parameters: string) => string;
+            /**
+             * returns html for placeholder element
+             */
+            placeholder?: (image: string, icon: string) => string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'No URL specified'
+             */
+            noURL?: string;
+            /**
+             * @default 'The method you called is not defined'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Modal
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/modal.html#/settings}
+     */
+    interface ModalSettings extends ComponentSettings {
+        // region Modal Settings
+
+        /**
+         * If set to false will prevent the modal from being moved to inside the dimmer
+         *
+         * @default true
+         */
+        detachable?: boolean;
+        /**
+         * When true, the first form input inside the modal will receive focus when shown. Set this to false to prevent this behavior.
+         *
+         * @default true
+         */
+        autofocus?: boolean;
+        /**
+         * Whether any change in modal DOM should automatically refresh cached positions
+         *
+         * @default false
+         */
+        observeChanges?: boolean;
+        /**
+         * If set to true will not close other visible modals when opening a new one
+         *
+         * @default false
+         */
+        allowMultiple?: boolean;
+        /**
+         * Whether to automatically bind keyboard shortcuts
+         *
+         * @default true
+         */
+        keyboardShortcuts?: boolean;
+        /**
+         *    A vertical offset to allow for content outside of modal, for example a close button, to be centered.
+         *
+         * @default 0
+         */
+        offset?: number;
+        /**
+         * Selector or jquery object specifying the area to dim
+         *
+         * @default 'body'
+         */
+        context?: Selector;
+        /**
+         * Setting to false will not allow you to close the modal by clicking on the dimmer
+         *
+         * @default true
+         */
+        closable?: boolean;
+        /**
+         * You can specify custom settings to extend UI dimmer
+         *
+         * @see {@link http://semantic-ui.com/modules/dimmer.html}
+         */
+        dimmerSettings?: DimmerSettings;
+        /**
+         * Named transition to use when animating menu in and out, full list can be found in ui transitions docs.
+         *
+         * @default 'scale'
+         * @see {@link http://semantic-ui.com/modules/transition.html}
+         */
+        transition?: string;
+        /**
+         * Duration of animation
+         *
+         * @default 400
+         */
+        duration?: number;
+        /**
+         * Whether additional animations should queue
+         *
+         * @default false
+         */
+        queue?: boolean;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Is called when a modal starts to show.
+         */
+        onShow?: (this: JQuery) => void;
+        /**
+         * Is called after a modal has finished showing animating.
+         */
+        onVisible?: (this: JQuery) => void;
+        /**
+         * Is called after a modal starts to hide. If the function returns false, the modal will not hide.
+         */
+        onHide?: (this: JQuery, $element: JQuery) => false | void;
+        /**
+         * Is called after a modal has finished hiding animation.
+         */
+        onHidden?: (this: JQuery) => void;
+        /**
+         * Is called after a positive, approve or ok button is pressed. If the function returns false, the modal will not hide.
+         */
+        onApprove?: (this: JQuery, $element: JQuery) => false | void;
+        /**
+         * Is called after a negative, deny or cancel button is pressed. If the function returns false the modal will not hide.
+         */
+        onDeny?: (this: JQuery, $element: JQuery) => false | void;
+
+        // endregion
+
+        // region DOM Settings
+
+        selector?: {
+            /**
+             * @default '.close, .actions .button'
+             */
+            close?: string;
+            /**
+             * @default '.actions .positive, .actions .approve, .actions .ok'
+             */
+            approve?: string;
+            /**
+             * @default '.actions .negative, .actions .deny, .actions .cancel'
+             */
+            deny?: string;
+        };
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'scrolling'
+             */
+            scrolling?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Nag
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/nag.html}
+     */
+    interface NagSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * allows cookie to be overridden
+         *
+         * @default false
+         */
+        persist?: boolean;
+        /**
+         * set to zero to require manually dismissal, otherwise hides on its own
+         *
+         * @default 0
+         */
+        displayTime?: number;
+        animation?: {
+            /**
+             * @default 'slide'
+             */
+            show?: string;
+            /**
+             * @default 'slide'
+             */
+            hide?: string;
+        };
+        /**
+         * @default false
+         */
+        context?: false | Selector;
+        /**
+         * @default false
+         */
+        detachable?: boolean;
+
+        /**
+         * @default 30
+         */
+        expires?: number;
+        /**
+         * @default false
+         */
+        domain?: false | string;
+        /**
+         * @default '/'
+         */
+        path?: string;
+
+        /**
+         * type of storage to use
+         *
+         * @default 'cookie'
+         */
+        storageMethod?: 'cookie' | 'localstorage' | 'sessionstorage';
+
+        /**
+         * @default 'nag'
+         */
+        key?: any;
+        /**
+         * @default 'dismiss'
+         */
+        value?: any;
+
+        /**
+         * @default 500
+         */
+        speed?: number;
+        /**
+         * @default 'easeOutQuad'
+         */
+        easing?: string;
+
+        // endregion
+
+        // region Callbacks
+
+        onHide?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        className?: {
+            /**
+             * @default 'bottom'
+             */
+            bottom?: string;
+            /**
+             * @default 'fixed'
+             */
+            fixed?: string;
+        };
+        selector?: {
+            /**
+             * @default '.close.icon'
+             */
+            close?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default '$.cookie is not included. A storage solution is required.'
+             */
+            noCookieStorage?: string;
+            /**
+             * @default 'Neither $.cookie or store is defined. A storage solution is required for storing state'
+             */
+            noStorage?: string;
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Popup
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/popup.html#/settings}
+     */
+    interface PopupSettings extends ComponentSettings {
+        // region Popup Settings
+
+        /**
+         * Can specify a DOM element that should be used as the popup. This is useful for including a pre-formatted popup.
+         *
+         * @default false
+         */
+        popup?: false | Selector;
+        /**
+         * Whether all other popups should be hidden when this popup is opened
+         *
+         * @default false
+         */
+        exclusive?: boolean;
+        /**
+         * Whether to move popup to same offset container as target element when popup already exists on the page.
+         * Using a popup inside of an element without overflow:visible, like a sidebar, may require you to set this to false
+         *
+         * @default true
+         */
+        movePopup?: boolean;
+        /**
+         * Whether popup should attach mutationObservers to automatically run destroy when the element is removed from the page's DOM.
+         *
+         * @default true
+         */
+        observeChanges?: boolean;
+        /**
+         * When the popup surpasses the boundary of this element, it will attempt to find another display position.
+         */
+        boundary?: Selector;
+        /**
+         * Selector or jquery object specifying where the popup should be created.
+         *
+         * @default 'body'
+         */
+        context?: Selector;
+        /**
+         * Will automatically hide a popup on scroll event in this context
+         */
+        scrollContext?: Selector;
+        /**
+         * Number of pixels that a popup is allowed to appear outside the boundaries of its context.
+         * This allows for permissible rounding errors when an element is against the edge of its context.
+         *
+         * @default 2
+         */
+        jitter?: number;
+        /**
+         * Position that the popup should appear
+         *
+         * @default 'top left'
+         */
+        position?: string;
+        /**
+         * If a popup is inline it will be created next to current element, allowing for local css rules to apply.
+         * It will not be removed from the DOM after being hidden.
+         * Otherwise popups will appended to body and removed after being hidden.
+         *
+         * @default false
+         */
+        inline?: boolean;
+        /**
+         * Whether popup contents should be preserved in the page after being hidden, allowing it to re-appear slightly faster on subsequent loads.
+         *
+         * @default false
+         */
+        preserve?: boolean;
+        /**
+         * Can be set to adjacent or opposite to prefer adjacent or opposite position if popup cannot fit on screen
+         *
+         * @default 'adjacent'
+         */
+        prefer?: 'adjacent' | 'opposite';
+        /**
+         * When set to false, a popup will not appear and produce an error message if it cannot entirely fit on page.
+         * Setting this to a position like, right center forces the popup to use this position as a last resort even if it is partially offstage.
+         * Setting this to true will use the last attempted position.
+         *
+         * @default false
+         */
+        lastResort?: boolean | string;
+        /**
+         * Event used to trigger popup. Can be either focus, click, hover, or manual. Manual popups must be triggered with $('.element').popup('show');
+         *
+         * @default 'hover'
+         */
+        on?: 'focus' | 'click' | 'hover' | 'manual';
+        /**
+         * Delay in milliseconds before showing or hiding a popup on hover or focus
+         */
+        delay?: {
+            show?: number;
+            hide?: number;
+        };
+        /**
+         * Named transition to use when animating menu in and out. Fade and slide down are available without including ui transitions
+         *
+         * @default 'slide down'
+         * @see {@link http://semantic-ui.com/modules/transition.html}
+         */
+        transition?: string;
+        /**
+         * Duration of animation events
+         *
+         * @default 200
+         */
+        duration?: number;
+        /**
+         * Whether popup should set fluid popup variation width on load to avoid width: 100% including padding
+         *
+         * @default true
+         */
+        setFluidWidth?: boolean;
+        /**
+         * Whether popup should not close on hover (useful for popup navigation menus)
+         *
+         * @default false
+         */
+        hoverable?: boolean;
+        /**
+         * When using on: 'click' specifies whether clicking the page should close the popup
+         *
+         * @default true
+         */
+        closable?: boolean;
+        /**
+         * When using on: 'hover' whether touchstart events should be added to allow the popup to be triggered
+         */
+        addTouchEvents?: boolean;
+        /**
+         * Whether popup should hide on scroll or touchmove, auto only hides for popups without on: 'click'.
+         * Set this to false to prevent mobile browsers from closing popups when you tap inside input fields.
+         *
+         * @default 'auto'
+         */
+        hideOnScroll?: 'auto' | false;
+        /**
+         * If a selector or jQuery object is specified this allows the popup to be positioned relative to that element.
+         *
+         * @default false
+         */
+        target?: false | Selector;
+        /**
+         * Offset for distance of popup from element
+         *
+         * @default 0
+         */
+        distanceAway?: number;
+        /**
+         * Offset in pixels from calculated position
+         *
+         * @default 0
+         */
+        offset?: number;
+        /**
+         * Number of iterations before giving up search for popup position when a popup cannot fit on screen
+         *
+         * @default 10
+         */
+        maxSearchDepth?: number;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback on popup element creation, with created popup
+         */
+        onCreate?: (this: JQuery, $module: JQuery) => void;
+        /**
+         * Callback immediately before Popup is removed from DOM
+         */
+        onRemove?: (this: JQuery, $module: JQuery) => void;
+        /**
+         * Callback before popup is shown. Returning false from this callback will cancel the popup from showing.
+         */
+        onShow?: (this: JQuery, $module: JQuery) => false | void;
+        /**
+         * Callback after popup is shown
+         */
+        onVisible?: (this: JQuery, $module: JQuery) => void;
+        /**
+         * Callback before popup is hidden. Returning false from this callback will cancel the popup from hiding.
+         */
+        onHide?: (this: JQuery, $module: JQuery) => false | void;
+        /**
+         * Callback after popup is hidden
+         */
+        onHidden?: (this: JQuery, $module: JQuery) => void;
+        /**
+         * Callback after popup cannot be plaed on screen
+         */
+        onUnplaceable?: (this: JQuery, $module: JQuery) => void;
+
+        // endregion
+
+        // region Content Settings
+
+        /**
+         * Popup variation to use, can use multiple variations with a space delimiter
+         */
+        variation?: string;
+        /**
+         * Content to display
+         */
+        content?: string;
+        /**
+         * Title to display alongside content
+         */
+        title?: string;
+        /**
+         * HTML content to display instead of preformatted title and content
+         */
+        html?: string;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * DOM Selectors used internally
+         */
+        selector?: {
+            /**
+             * @default '.ui.popup'
+             */
+            popup?: string;
+        };
+        /**
+         * HTML Data attributes used to store data
+         */
+        metadata?: {
+            /**
+             * @default 'content'
+             */
+            content?: string;
+            /**
+             * @default 'html'
+             */
+            html?: string;
+            /**
+             * @default 'offset'
+             */
+            offset?: string;
+            /**
+             * @default 'position'
+             */
+            position?: string;
+            /**
+             * @default 'title'
+             */
+            title?: string;
+            /**
+             * @default 'variation'
+             */
+            variation?: string;
+        };
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'ui popup'
+             */
+            popup?: string;
+            /**
+             * @default 'top left center bottom right'
+             */
+            position?: string;
+            /**
+             * @default 'visible'
+             */
+            visible?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The position you specified is not a valid position'
+             */
+            invalidPosition?: string;
+            /**
+             * @default 'Popup does not fit within the boundaries of the viewport'
+             */
+            cannotPlace?: string;
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+            /**
+             * @default 'This module requires ui transitions <https: github.com="" semantic-org="" ui-transition="">'
+             */
+            noTransition?: string;
+            /**
+             * @default 'The target or popup you specified does not exist on the page'
+             */
+            notFound?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Progress
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/progress.html#/settings}
+     */
+    interface ProgressSettings extends ComponentSettings {
+        // region Progress Settings
+
+        /**
+         * Whether success state should automatically trigger when progress completes
+         *
+         * @default true
+         */
+        autoSuccess?: boolean;
+        /**
+         * Whether progress should automatically show activity when incremented
+         *
+         * @default true
+         */
+        showActivity?: boolean;
+        /**
+         * When set to true, values that calculate to above 100% or below 0% will be adjusted.
+         * When set to false, inappropriate values will produce an error.
+         *
+         * @default true
+         */
+        limitValues?: boolean;
+        /**
+         * Can be set to either to display progress as percent or ratio. Matches up to corresponding text template with the same name.
+         *
+         * @default 'percent'
+         */
+        label?: 'percent' | 'ratio';
+        /**
+         * When incrementing without value, sets range for random increment value
+         */
+        random?: {
+            /**
+             * @default 2
+             */
+            min?: number;
+            /**
+             * @default 5
+             */
+            max?: number;
+        };
+        /**
+         * Decimal point precision for calculated progress
+         *
+         * @default 1
+         */
+        precision?: number;
+        /**
+         * Setting a total value will make each call to increment get closer to this total (i.e. 1/20, 2/20 etc)
+         *
+         * @default false
+         */
+        total?: false | number;
+        /**
+         * Sets current value, when total is specified, this is used to calculate a ratio of the total, with percent this should be the overall percent
+         *
+         * @default false
+         */
+        value?: false | number;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback on percentage change
+         */
+        onChange?: (this: JQuery, percent: number, value: number, total: number) => void;
+        /**
+         * Callback on success state
+         */
+        onSuccess?: (this: JQuery, total: number) => void;
+        /**
+         * Callback on active state
+         */
+        onActive?: (this: JQuery, value: number, total: number) => void;
+        /**
+         * Callback on error state
+         */
+        onError?: (this: JQuery, value: number, total: number) => void;
+        /**
+         * Callback on warning state
+         */
+        onWarning?: (this: JQuery, value: number, total: number) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Text content for each state, uses simple templating with {percent}, {value}, {total}
+         */
+        text?: {
+            /**
+             * @default false
+             */
+            active?: false | string;
+            /**
+             * @default false
+             */
+            error?: false | string;
+            /**
+             * @default false
+             */
+            success?: false | string;
+            /**
+             * @default false
+             */
+            warning?: false | string;
+            /**
+             * @default '{percent}%'
+             */
+            percent?: false | string;
+            /**
+             * @default '{value} of {total}'
+             */
+            ratio?: false | string;
+        };
+        /**
+         * Regular expressions used by module
+         */
+        regExp?: {
+            /**
+             * @default /\{\$*[A-z0-9]+\}/g
+             */
+            variable?: RegExp;
+        };
+        /**
+         * Selectors used by module
+         */
+        selector?: {
+            /**
+             * @default '> .bar
+             */
+            bar?: string;
+            /**
+             * @default '> .label'
+             */
+            label?: string;
+            /**
+             * @default '.bar > .progress'
+             */
+            progress?: string;
+        };
+        /**
+         * DOM metadata used by module
+         */
+        metadata?: {
+            /**
+             * @default 'percent'
+             */
+            percent?: string;
+            /**
+             * @default 'total'
+             */
+            total?: string;
+            /**
+             * @default 'value'
+             */
+            value?: string;
+        };
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'error'
+             */
+            error?: string;
+            /**
+             * @default 'success'
+             */
+            success?: string;
+            /**
+             * @default 'warning'
+             */
+            warning?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+            /**
+             * @default 'Progress value is non numeric'
+             */
+            nonNumeric?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Rating
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/rating.html#/settings}
+     */
+    interface RatingSettings extends ComponentSettings {
+        // region Rating Settings
+
+        /**
+         * A number representing the default rating to apply
+         *
+         * @default 0
+         */
+        initialRating?: number;
+        /**
+         * Whether callbacks like onRate should fire immediately after initializing with the current value.
+         *
+         * @default false
+         */
+        fireOnInit?: boolean;
+        /**
+         * By default a rating will be only clearable if there is 1 icon. Setting to true/false will allow or disallow a user to clear their rating
+         *
+         * @default 'auto'
+         */
+        clearable?: 'auto' | boolean;
+        /**
+         * Whether to enable user's ability to rate
+         *
+         * @default true
+         */
+        interactive?: boolean;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Is called after user selects a new rating
+         */
+        onRate?: (this: JQuery, value: number) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        selector?: {
+            /**
+             * @default '.icon'
+             */
+            icon?: string;
+        };
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'hover'
+             */
+            hover?: string;
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'You called a rating action that was not defined'
+             */
+            action?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Search
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/search.html#/settings}
+     */
+    interface SearchSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * Settings for API call.
+         *
+         * @see {@link http://semantic-ui.com/behaviors/api.html#/usage}
+         */
+        apiSettings?: ApiSettings;
+        /**
+         * Minimum characters to query for results
+         *
+         * @default 1
+         */
+        minCharacters?: number;
+        /**
+         * Named transition to use when animating menu in and out. Fade and slide down are available without including ui transitions
+         *
+         * @default 'fade'
+         * @see {@link http://semantic-ui.com/modules/transition.html}
+         */
+        transition?: string;
+        /**
+         * Duration of animation events
+         *
+         * @default 300
+         */
+        duration?: number;
+        /**
+         * Maximum results to display when using local and simple search, maximum category count for category search
+         *
+         * @default 7
+         */
+        maxResults?: number;
+        /**
+         * Caches results locally to avoid requerying server
+         *
+         * @default true
+         */
+        cache?: boolean;
+        /**
+         * Specify a Javascript object which will be searched locally
+         *
+         * @default false
+         */
+        source?: false | any;
+        /**
+         * Whether the search should automatically select the first search result after searching
+         *
+         * @default false
+         */
+        selectFirstResult?: boolean;
+        /**
+         * Whether a "no results" message should be shown if no results are found. (These messages can be modified using the template object specified below)
+         *
+         * @default false
+         */
+        showNoResults?: boolean;
+        /**
+         * Return local results that match anywhere inside your content
+         *
+         * @default true
+         */
+        searchFullText?: boolean;
+        /**
+         * List mapping display content to JSON property, either with API or source.
+         */
+        fields?: {
+            /**
+             * array of categories (category view)
+             *
+             * @default 'results'
+             */
+            categories?: string;
+            /**
+             * name of category (category view)
+             *
+             * @default 'name'
+             */
+            categoryName?: string;
+            /**
+             * array of results (category view)
+             *
+             * @default 'results'
+             */
+            categoryResults?: string;
+            /**
+             * result description
+             *
+             * @default 'description'
+             */
+            description?: string;
+            /**
+             * result image
+             *
+             * @default 'image'
+             */
+            image?: string;
+            /**
+             * result price
+             *
+             * @default 'price'
+             */
+            price?: string;
+            /**
+             * array of results (standard)
+             *
+             * @default 'results'
+             */
+            results?: string;
+            /**
+             * result title
+             *
+             * @default 'title'
+             */
+            title?: string;
+            /**
+             * "view more" object name
+             *
+             * @default 'action'
+             */
+            action?: string;
+            /**
+             * "view more" text
+             *
+             * @default 'text'
+             */
+            actionText?: string;
+            /**
+             * "view more" url
+             *
+             * @default 'url'
+             */
+            actionURL?: string;
+        };
+        /**
+         * Specify object properties inside local source object which will be searched
+         */
+        searchFields?: string[];
+        /**
+         * Delay before hiding results after search blur
+         *
+         * @default 0
+         */
+        hideDelay?: number;
+        /**
+         * Delay before querying results on inputchange
+         *
+         * @default 100
+         */
+        searchDelay?: number;
+        /**
+         * Easing equation when using fallback Javascript animation
+         *
+         * @default 'easeOutExpo'
+         */
+        easing?: string;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback on element selection by user.
+         * The first parameter includes the filtered response results for that element.
+         * The function should return false to prevent default action (closing search results and selecting value).
+         */
+        onSelect?: (this: JQuery, result: any, response: any) => false | void;
+        /**
+         * Callback after processing element template to add HTML to results. Function should return false to prevent default actions.
+         */
+        onResultsAdd?: (this: JQuery, html: string) => false | void;
+        /**
+         * Callback on search query
+         */
+        onSearchQuery?: (this: JQuery, query: string) => void;
+        /**
+         * Callback on server response
+         */
+        onResults?: (this: JQuery, response: any) => void;
+        /**
+         * Callback when results are opened
+         */
+        onResultsOpen?: (this: JQuery) => void;
+        /**
+         * Callback when results are closed
+         */
+        onResultsClose?: (this: JQuery) => void;
+
+        // endregion
+
+        // region Templates
+
+        templates?: {
+            escape?: (string: string) => string;
+            message?: (message: string, type: string) => string;
+            category?: (response: any) => string;
+            standard?: (response: any) => string;
+        };
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Regular expressions used for matching
+         */
+        regExp?: {
+            /**
+             * @default /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g
+             */
+            escape?: RegExp;
+            /**
+             * @default '(?:\s|^)'
+             */
+            beginsWith?: string;
+        };
+        /**
+         * Selectors used to find parts of a module
+         */
+        selector?: {
+            /**
+             * @default '.prompt'
+             */
+            prompt?: string;
+            /**
+             * @default '.search.button'
+             */
+            searchButton?: string;
+            /**
+             * @default '.results'
+             */
+            results?: string;
+            /**
+             * @default '.category'
+             */
+            category?: string;
+            /**
+             * @default '.result'
+             */
+            result?: string;
+        };
+        /**
+         * HTML5 metadata attributes used internally
+         */
+        metadata?: {
+            /**
+             * @default 'cache'
+             */
+            cache?: string;
+            /**
+             * @default 'results'
+             */
+            results?: string;
+        };
+        /**
+         * Class names used to determine element state
+         */
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'empty'
+             */
+            empty?: string;
+            /**
+             * @default 'focus'
+             */
+            focus?: string;
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'down'
+             */
+            pressed?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'Cannot search. No source used, and Semantic API module was not included'
+             */
+            source?: string;
+            /**
+             * @default 'Your search returned no results'
+             */
+            noResults?: string;
+            /**
+             * @default 'Error in debug logging, exiting.'
+             */
+            logging?: string;
+            /**
+             * @default 'A valid template name was not specified.'
+             */
+            noTemplate?: string;
+            /**
+             * @default 'There was an issue with querying the server.'
+             */
+            serverError?: string;
+            /**
+             * @default 'Results must be an array to use maxResults setting'
+             */
+            maxResults?: string;
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Shape
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/shape.html#/settings}
+     */
+    interface ShapeSettings extends ComponentSettings {
+        // region Shape Settings
+
+        /**
+         * Duration of side change animation
+         *
+         * @default 700
+         */
+        duration?: number;
+        /**
+         * When set to next will use the width of the next side during the shape's animation.
+         * When set to initial it will use the width of the shape at initialization.
+         * When set to a specific pixel height, will force the width to that height.
+         *
+         * @default 'initial'
+         * @since 2.2
+         */
+        width?: 'next' | 'initial' | number;
+        /**
+         * When set to next will use the height of the next side during the shape's animation.
+         * When set to initial it will use the height of the shape at initialization.
+         * When set to a specific pixel height, will force the height to that height.
+         *
+         * @default 'initial'
+         * @since 2.2
+         */
+        height?: 'next' | 'initial' | number;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Is called before side change
+         */
+        beforeChange?: (this: JQuery) => void;
+        /**
+         * Is called after visible side change
+         */
+        onChange?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        selector?: {
+            /**
+             * @default '.sides'
+             */
+            sides?: string;
+            /**
+             * @default '.side'
+             */
+            side?: string;
+        };
+        className?: {
+            /**
+             * @default 'animating'
+             */
+            animating?: string;
+            /**
+             * @default 'hidden'
+             */
+            hidden?: string;
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'active'
+             */
+            active?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'You tried to switch to a side that does not exist.'
+             */
+            side?: string;
+            /**
+             * @default 'The method you called is not defined'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    interface Translation {
+        transform: string;
+    }
+
+    // endregion
+
+    // region Sidebar
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/sidebar.html#/settings}
+     */
+    interface SidebarSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * Context which sidebar will appear inside
+         *
+         * @default 'body'
+         */
+        context?: Selector;
+        /**
+         * Whether multiple sidebars can be open at once
+         *
+         * @default false
+         */
+        exclusive?: boolean;
+        /**
+         * Whether sidebar can be closed by clicking on page
+         *
+         * @default true
+         */
+        closable?: boolean;
+        /**
+         * Whether to dim page contents when sidebar is visible
+         *
+         * @default true
+         */
+        dimPage?: boolean;
+        /**
+         * Whether to lock page scroll when sidebar is visible
+         *
+         * @default false
+         */
+        scrollLock?: boolean;
+        /**
+         * Whether to return to original scroll position when sidebar is hidden, automatically occurs with transition: scale
+         *
+         * @default false
+         */
+        returnScroll?: boolean;
+        /**
+         * When sidebar is initialized without the proper HTML, using this option will defer creation of DOM to use requestAnimationFrame.
+         *
+         * @default false
+         */
+        delaySetup?: boolean;
+
+        // endregion
+
+        // region Animation
+
+        /**
+         * Named transition to use when animating sidebar. Defaults to 'auto' which selects transition from defaultTransition based on direction.
+         *
+         * @default 'auto'
+         */
+        transition?: string;
+        /**
+         * Named transition to use when animating when detecting mobile device. Defaults to 'auto' which selects transition from defaultTransition based on direction.
+         *
+         * @default 'auto'
+         */
+        mobileTransition?: string;
+        /**
+         * Default transitions for each direction and screen size, used with transition: auto
+         */
+        defaultTransition?: {
+            computer?: {
+                /**
+                 * @default 'uncover'
+                 */
+                left?: string;
+                /**
+                 * @default 'uncover'
+                 */
+                right?: string;
+                /**
+                 * @default 'overlay'
+                 */
+                top?: string;
+                /**
+                 * @default 'overlay'
+                 */
+                bottom?: string;
+            };
+            mobile?: {
+                /**
+                 * @default 'uncover'
+                 */
+                left?: string;
+                /**
+                 * @default 'uncover'
+                 */
+                right?: string;
+                /**
+                 * @default 'overlay'
+                 */
+                top?: string;
+                /**
+                 * @default 'overlay'
+                 */
+                bottom?: string;
+            };
+        };
+        /**
+         * Whether Javascript animations should be used. Defaults to false. Setting to auto will use legacy animations only for browsers that do not support CSS transforms
+         *
+         * @default false
+         */
+        useLegacy?: 'auto' | boolean;
+        /**
+         * Duration of sidebar animation when using legacy Javascript animation
+         *
+         * @default 500
+         */
+        duration?: number;
+        /**
+         * Easing to use when using legacy Javascript animation
+         *
+         * @default 'easeInOutQuint'
+         */
+        easing?: string;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Is called when a sidebar begins animating in.
+         */
+        onVisible?: (this: JQuery) => void;
+        /**
+         * Is called when a sidebar has finished animating in.
+         */
+        onShow?: (this: JQuery) => void;
+        /**
+         * Is called when a sidebar begins to hide or show
+         */
+        onChange?: (this: JQuery) => void;
+        /**
+         * Is called before a sidebar begins to animate out.
+         */
+        onHide?: (this: JQuery) => void;
+        /**
+         * Is called after a sidebar has finished animating out.
+         */
+        onHidden?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'animating'
+             */
+            animating?: string;
+            /**
+             * @default 'dimmed'
+             */
+            dimmed?: string;
+            /**
+             * @default 'ios'
+             */
+            ios?: string;
+            /**
+             * @default 'pushable'
+             */
+            pushable?: string;
+            /**
+             * @default 'pushed'
+             */
+            pushed?: string;
+            /**
+             * @default 'right'
+             */
+            right?: string;
+            /**
+             * @default 'top'
+             */
+            top?: string;
+            /**
+             * @default 'left'
+             */
+            left?: string;
+            /**
+             * @default 'bottom'
+             */
+            bottom?: string;
+            /**
+             * @default 'visible'
+             */
+            visible?: string;
+        };
+        regExp?: {
+            /**
+             * @default /(iPad|iPhone|iPod)/g
+             */
+            ios?: RegExp;
+            /**
+             * @default /Mobile|iP(hone|od|ad)|Android|BlackBerry|IEMobile|Kindle|NetFront|Silk-Accelerated|(hpw|web)OS|Fennec|Minimo|Opera M(obi|ini)|Blazer|Dolfin|Dolphin|Skyfire|Zune/g
+             */
+            mobile?: RegExp;
+        };
+        selector?: {
+            /**
+             * @default '.fixed'
+             */
+            fixed?: string;
+            /**
+             * @default 'script, link, style, .ui.modal, .ui.dimmer, .ui.nag, .ui.fixed'
+             */
+            omitted?: string;
+            /**
+             * @default '.pusher'
+             */
+            pusher?: string;
+            /**
+             * @default '.ui.sidebar'
+             */
+            sidebar?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+            /**
+             * @default 'Had to add pusher element. For optimal performance make sure body content is inside a pusher element'
+             */
+            pusher?: string;
+            /**
+             * @default 'Had to move sidebar. For optimal performance make sure sidebar and pusher are direct children of your body tag'
+             */
+            movedSidebar?: string;
+            /**
+             * @default 'The overlay setting is no longer supported, use animation: overlay'
+             */
+            overlay?: string;
+            /**
+             * @default 'There were no elements that matched the specified selector'
+             */
+            notFound?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Sticky
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/sticky.html#/settings}
+     */
+    interface StickySettings extends ComponentSettings {
+        // region Sticky Settings
+
+        /**
+         * Whether element should be "pushed" by the viewport, attaching to the bottom of the screen when scrolling up
+         *
+         * @default false
+         */
+        pushing?: boolean;
+        /**
+         * Sticky container height will only be set if the difference between heights of container and context is larger than this jitter value.
+         *
+         * @default 5
+         */
+        jitter?: number;
+        /**
+         * Whether any change in context DOM should automatically refresh cached sticky positions
+         *
+         * @default false
+         */
+        observeChanges?: boolean;
+        /**
+         * Context which sticky element should stick to
+         *
+         * @default false
+         */
+        context?: false | Selector;
+        /**
+         * Context which sticky should attach onscroll events.
+         *
+         * @default 'window'
+         */
+        scrollContext?: Selector;
+        /**
+         * Offset in pixels from the top of the screen when fixing element to viewport
+         *
+         * @default 0
+         */
+        offset?: number;
+        /**
+         * Offset in pixels from the bottom of the screen when fixing element to viewport
+         *
+         * @default 0
+         */
+        bottomOffset?: number;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback when element is repositioned from layout change
+         */
+        onReposition?: (this: JQuery) => void;
+        /**
+         * Callback when requestAnimationFrame fires from scroll handler.
+         */
+        onScroll?: (this: JQuery) => void;
+        /**
+         * Callback when element is fixed to page
+         */
+        onStick?: (this: JQuery) => void;
+        /**
+         * Callback when element is unfixed from page
+         */
+        onUnstick?: (this: JQuery) => void;
+        /**
+         * Callback when element is bound to top of parent container
+         */
+        onTop?: (this: JQuery) => void;
+        /**
+         * Callback when element is bound to bottom of parent container
+         */
+        onBottom?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'bound'
+             */
+            bound?: string;
+            /**
+             * @default 'fixed'
+             */
+            fixed?: string;
+            /**
+             * @default 'native'
+             */
+            supported?: string;
+            /**
+             * @default 'top'
+             */
+            top?: string;
+            /**
+             * @default 'bottom'
+             */
+            bottom?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'Sticky element must be inside a relative container'
+             */
+            container?: string;
+            /**
+             * @default 'Element is hidden, you must call refresh after element becomes visible'
+             */
+            visible?: string;
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+            /**
+             * @default 'Context specified does not exist'
+             */
+            invalidContext?: string;
+            /**
+             * @default 'Sticky element is larger than its container, cannot create sticky.'
+             */
+            elementSize?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Tab
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/tab.html#/settings}
+     */
+    interface TabSettings extends ComponentSettings {
+        // region Tab Settings
+
+        /**
+         * Whether tab should load remote content as same url as history
+         *
+         * @default false
+         */
+        auto?: boolean;
+        /**
+         * When set to siblings will only deactivate elements that are DOM siblings with the activated element.
+         * When set to all the component will deactivate all other elements initialized at the same time.
+         *
+         * @default 'siblings'
+         * @since 2.2
+         */
+        deactivate?: 'siblings' | 'all';
+        /**
+         * Whether to record history events for tab changes
+         *
+         * @default false
+         */
+        history?: boolean;
+        /**
+         * Do not load content remotely on first tab load. Useful when open tab is rendered on server.
+         *
+         * @default false
+         */
+        ignoreFirstLoad?: boolean;
+        /**
+         * Whether inline scripts in tab HTML should be parsed on tab load.
+         * Defaults to once, parsing only on first load.
+         * Can also be set to true or false to always parse or never parse inline scripts.
+         *
+         * @default 'once'
+         */
+        evaluateScripts?: 'once' | boolean;
+        /**
+         * Tab should reload content every time it is opened
+         */
+        alwaysRefresh?: boolean;
+        /**
+         * Can be set to either response, DOM or html.
+         * Using DOM will cache the a clone of the DOM tree, preserving all events as they existed on render.
+         * response will cache the original response on load, this way callbacks always receive the same content.
+         * Using html will cache the resulting html after all callbacks, making sure any changes to content are preserved.
+         *
+         * @default 'response'
+         */
+        cacheType?: 'response' | 'DOM' | 'html';
+        /**
+         * Tab should cache content after loading locally to avoid server trip on second load
+         *
+         * @default true
+         */
+        cache?: boolean;
+        /**
+         * Settings object for $.api call
+         *
+         * @default false
+         * @see {@link http://semantic-ui.com/behaviors/api.html}
+         */
+        apiSettings?: ApiSettings;
+        /**
+         * Can be set to hash or state.
+         * Hash will use an in-page link to create history events.
+         * State will use DOM History and load pages from server on refresh.
+         *
+         * @default 'hash'
+         * @see {@link https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Manipulating_the_browser_history}
+         */
+        historyType?: 'hash' | 'state';
+        /**
+         * When using historyType state you must specify the base URL for all internal links.
+         *
+         * @default false
+         */
+        path?: false | string;
+        /**
+         * Tabs are limited to those found inside this context
+         *
+         * @default false
+         */
+        context?: false | Selector;
+        /**
+         * If enabled limits tabs to children of passed context
+         *
+         * @default false
+         */
+        childrenOnly?: boolean;
+        /**
+         * Maximum amount of nested tabs allowed (avoids recursion)
+         *
+         * @default 25
+         */
+        maxDepth?: number;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback only the first time a tab is loaded
+         */
+        onFirstLoad?: (this: JQuery, tabPath: string, parameterArray: any[], historyEvent: any) => void;
+        /**
+         * Callback every time a tab is loaded
+         */
+        onLoad?: (this: JQuery, tabPath: string, parameterArray: any[], historyEvent: any) => void;
+        /**
+         * Called when a tab begins loading remote content
+         */
+        onRequest?: (this: JQuery, tabPath: string) => void;
+        /**
+         * Called after a tab becomes visible
+         */
+        onVisible?: (this: JQuery, tabPath: string) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Functions used to return content
+         */
+        templates?: {
+            /**
+             * returns page title
+             */
+            determineTitle?: (tabArray: any[]) => string;
+        };
+        /**
+         * Selectors used by module
+         */
+        selector?: {
+            /**
+             * @default '.ui.tab'
+             */
+            tabs?: string;
+            /**
+             * @default '.ui:not(.menu)'
+             */
+            parent?: string;
+        };
+        /**
+         * DOM metadata used by module
+         */
+        metadata?: {
+            /**
+             * @default 'tab'
+             */
+            tab?: string;
+            /**
+             * @default 'loaded'
+             */
+            loaded?: string;
+            /**
+             * @default 'promise'
+             */
+            promise?: string;
+        };
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'active'
+             */
+            active?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'You attempted to load content without API module'
+             */
+            api?: string;
+            /**
+             * @default 'The method you called is not defined'
+             */
+            method?: string;
+            /**
+             * @default 'Activated tab cannot be found for this context.'
+             */
+            missingTab?: string;
+            /**
+             * @default 'The tab you specified is missing a content url.'
+             */
+            noContent?: string;
+            /**
+             * @default 'History enabled, but no path was specified'
+             */
+            path?: string;
+            /**
+             * @default 'Max recursive depth reached'
+             */
+            recursion?: string;
+            /**
+             * @default 'The state library has not been initialized'
+             */
+            state?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Transition
+
+    /**
+     * @see {@link http://semantic-ui.com/modules/transition.html#/settings}
+     */
+    interface TransitionSettings extends ComponentSettings {
+        // region Transition Settings
+
+        /**
+         * Named animation event to used. Must be defined in CSS.
+         *
+         * @default 'fade'
+         */
+        animation?: string;
+        /**
+         * Interval in MS between each elements transition
+         *
+         * @default 0
+         */
+        interval?: number;
+        /**
+         * When an interval is specified, sets order of animations. auto reverses only animations that are hiding.
+         *
+         * @default 'auto'
+         */
+        reverse?: 'auto' | boolean;
+        /**
+         * Specify the final display type (block, inline-block etc) so that it doesn't have to be calculated.
+         *
+         * @default false
+         */
+        displayType?: false | string;
+        /**
+         * Duration of the CSS transition animation
+         *
+         * @default 500
+         */
+        duration?: number;
+        /**
+         * If enabled a timeout will be added to ensure animationend callback occurs even if element is hidden
+         */
+        useFailSafe?: boolean;
+        /**
+         * If enabled will allow same animation to be queued while it is already occurring
+         */
+        allowRepeats?: boolean;
+        /**
+         * Whether to automatically queue animation if another is occurring
+         */
+        queue?: boolean;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback on each transition that changes visibility to shown
+         */
+        onShow?: (this: JQuery) => void;
+        /**
+         * Callback on each transition that changes visibility to hidden
+         */
+        onHide?: (this: JQuery) => void;
+        /**
+         * Callback on animation start, useful for queued animations
+         */
+        onStart?: (this: JQuery) => void;
+        /**
+         * Callback on each transition complete
+         */
+        onComplete?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'animating'
+             */
+            animating?: string;
+            /**
+             * @default 'disabled'
+             */
+            disabled?: string;
+            /**
+             * @default 'hidden'
+             */
+            hidden?: string;
+            /**
+             * @default 'in'
+             */
+            inward?: string;
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'looping'
+             */
+            looping?: string;
+            /**
+             * @default 'out'
+             */
+            outward?: string;
+            /**
+             * @default 'transition'
+             */
+            transition?: string;
+            /**
+             * @default 'visible'
+             */
+            visible?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'There is no CSS animation matching the one you specified.'
+             */
+            noAnimation?: string;
+            /**
+             * @default 'The method you called is not defined'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // endregion
+
+    // region Behaviors
+
+    // region API
+
+    /**
+     * @see {@link http://semantic-ui.com/behaviors/api.html#/settings}
+     */
+    interface ApiSettings extends ComponentSettings {
+        // region Behavior
+
+        /**
+         * When API event should occur
+         *
+         * @default 'auto'
+         */
+        on?: string;
+        /**
+         * Can be set to 'local' to cache successful returned AJAX responses when using a JSON API.
+         * This helps avoid server round trips when API endpoints will return the same results when accessed repeatedly.
+         * Setting to false, will add cache busting parameters to the URL.
+         *
+         * @default true
+         */
+        cache?: 'local' | boolean;
+        /**
+         * UI state will be applied to this element, defaults to triggering element.
+         */
+        stateContext?: Selector;
+        /**
+         * Whether to encode parameters with encodeURIComponent before adding into url string
+         *
+         * @default true
+         */
+        encodeParameters?: boolean;
+        /**
+         * Whether to automatically include default data like {value} and {text}
+         *
+         * @default true
+         */
+        defaultData?: boolean;
+        /**
+         * Whether to serialize closest form and include in request
+         *
+         * @default false
+         */
+        serializeForm?: boolean;
+        /**
+         * How long to wait when a request is made before triggering request, useful for rate limiting oninput
+         *
+         * @default 0
+         */
+        throttle?: number;
+        /**
+         * When set to false will not delay the first request made, when no others are queued
+         *
+         * @default true
+         */
+        throttleFirstRequest?: boolean;
+        /**
+         * Whether an API request can occur while another request is still pending
+         *
+         * @default false
+         */
+        interruptRequests?: boolean;
+        /**
+         * Minimum duration to show loading indication
+         *
+         * @default 0
+         */
+        loadingDuration?: number;
+        /**
+         * The default auto will automatically remove error state after error duration, unless the element is a form
+         *
+         * @default 'auto'
+         */
+        hideError?: 'auto' | boolean;
+        /**
+         * Setting to true, will not remove error.
+         * Setting to a duration in milliseconds to show error state after request error.
+         *
+         * @default 2000
+         */
+        errorDuration?: true | number;
+
+        // endregion
+
+        // region Request Settings
+
+        /**
+         * Named API action for query, originally specified in $.fn.settings.api
+         */
+        action?: string | false;
+        /**
+         * Templated URL for query, will override specified action
+         */
+        url?: string | false;
+        /**
+         * Variables to use for replacement
+         */
+        urlData?: any | false;
+        /**
+         * Can be set to a Javascript object which will be returned automatically instead of requesting JSON from server
+         */
+        response?: any | false;
+        /**
+         * When specified, this function can be used to retrieve content from a server and return it asynchronously instead of a standard AJAX call.
+         * The callback function should return the server response.
+         *
+         * @default false
+         */
+        responseAsync?: ((settings: ApiSettings, callback: (response: any) => void) => void) | false;
+        /**
+         * @see response
+         */
+        mockResponse?: any | false;
+        /**
+         * @see responseAsync
+         */
+        mockResponseAsync?: ((settings: ApiSettings, callback: (response: any) => void) => void) | false;
+        /**
+         * Method for transmitting request to server
+         */
+        method?: 'post' | 'get';
+        /**
+         * Expected data type of response
+         */
+        dataType?: 'xml' | 'json' | 'jsonp' | 'script' | 'html' | 'text';
+        /**
+         * POST/GET Data to Send with Request
+         */
+        data?: any;
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Allows modifying settings before request, or cancelling request
+         */
+        beforeSend?: (settings: ApiSettings) => any;
+        /**
+         * Allows modifying XHR object for request
+         */
+        beforeXHR?: (xhrObject: JQueryXHR) => any;
+        /**
+         * Callback that occurs when request is made. Receives both the API success promise and the XHR request promise.
+         */
+        onRequest?: (promise: JQueryDeferred<any>, xhr: JQueryXHR) => void;
+        /**
+         * Allows modifying the server's response before parsed by other callbacks to determine API event success
+         */
+        onResponse?: (response: any) => void;
+        /**
+         * Determines whether completed JSON response should be treated as successful
+         *
+         * @see {@link http://semantic-ui.com/behaviors/api.html#determining-json-success}
+         */
+        successTest?: (response: any) => boolean;
+        /**
+         * Callback after successful response, JSON response must pass successTest
+         */
+        onSuccess?: (response: any, element: JQuery, xhr: JQueryXHR) => void;
+        /**
+         * Callback on request complete regardless of conditions
+         */
+        onComplete?: (response: any, element: JQuery, xhr: JQueryXHR) => void;
+        /**
+         * Callback on failed response, or JSON response that fails successTest
+         */
+        onFailure?: (response: any, element: JQuery) => void;
+        /**
+         * Callback on server error from returned status code, or XHR failure.
+         */
+        onError?: (errorMessage: string, element: JQuery, xhr: JQueryXHR) => void;
+        /**
+         * Callback on abort caused by user clicking a link or manually cancelling request.
+         */
+        onAbort?: (errorMessage: string, element: JQuery, xhr: JQueryXHR) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Regular expressions used for template matching
+         */
+        regExp?: {
+            /**
+             * @default /\{\$*[A-z0-9]+\}/g
+             */
+            required?: RegExp;
+            /**
+             * @default /\{\/\$*[A-z0-9]+\}/g
+             */
+            optional?: RegExp;
+        };
+        /**
+         * Selectors used to find parts of a module
+         */
+        selector?: {
+            /**
+             * @default '.disabled'
+             */
+            disabled?: string;
+            /**
+             * @default 'form'
+             */
+            form?: string;
+        };
+        /**
+         * Class names used to determine element state
+         */
+        className?: {
+            /**
+             * @default 'loading'
+             */
+            loading?: string;
+            /**
+             * @default 'error'
+             */
+            error?: string;
+        };
+        /**
+         * Metadata used to store XHR and response promise
+         */
+        metadata?: {
+            /**
+             * @default 'action'
+             */
+            action?: string;
+            /**
+             * @default 'url'
+             */
+            url?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The before send function has aborted the request'
+             */
+            beforeSend?: string;
+            /**
+             * @default 'There was an error with your request'
+             */
+            error?: string;
+            /**
+             * @default 'API Request Aborted. Exit conditions met'
+             */
+            exitConditions?: string;
+            /**
+             * @default 'JSON could not be parsed during error handling'
+             */
+            JSONParse?: string;
+            /**
+             * @default 'You are using legacy API success callback names'
+             */
+            legacyParameters?: string;
+            /**
+             * @default 'API action used but no url was defined'
+             */
+            missingAction?: string;
+            /**
+             * @default 'Required dependency jquery-serialize-object missing, using basic serialize'
+             */
+            missingSerialize?: string;
+            /**
+             * @default 'No URL specified for API event'
+             */
+            missingURL?: string;
+            /**
+             * @default 'The beforeSend callback must return a settings object, beforeSend ignored.'
+             */
+            noReturnedValue?: string;
+            /**
+             * @default 'There was an error parsing your request'
+             */
+            parseError?: string;
+            /**
+             * @default 'Missing a required URL parameter: '
+             */
+            requiredParameter?: string;
+            /**
+             * @default 'Server gave an error: '
+             */
+            statusMessage?: string;
+            /**
+             * @default 'Your request timed out'
+             */
+            timeout?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Form Validation
+
+    /**
+     * @see {@link http://semantic-ui.com/behaviors/form.html#/settings}
+     */
+    interface FormSettings extends ComponentSettings {
+        // region Form Settings
+
+        /**
+         * Adds keyboard shortcuts for enter and escape keys to submit form and blur fields respectively
+         *
+         * @default true
+         */
+        keyboardShortcuts?: boolean;
+        /**
+         * Event used to trigger validation. Can be either submit, blur or change.
+         *
+         * @default 'submit'
+         */
+        on?: 'submit' | 'blur' | 'change';
+        /**
+         * If set to true will revalidate fields with errors on input change
+         *
+         * @default true
+         */
+        revalidate?: boolean;
+        /**
+         * Delay from last typed letter to validate a field when using on: change or when revalidating a field.
+         *
+         * @default true
+         */
+        delay?: boolean;
+        /**
+         * Adds inline error on field validation error
+         *
+         * @default false
+         */
+        inline?: boolean;
+        /**
+         * Named transition to use when animating validation errors. Fade and slide down are available without including ui transitions
+         *
+         * @default 'scale'
+         * @see {@link http://semantic-ui.com/modules/transition.html}
+         */
+        transition?: string;
+        /**
+         * Animation speed for inline prompt
+         *
+         * @default 150
+         */
+        duration?: number;
+
+        // endregion
+
+        // region Form Prompts
+
+        text?: {
+            /**
+             * @default 'Please enter a valid value'
+             */
+            unspecifiedRule?: string;
+            /**
+             * @default 'This field'
+             */
+            unspecifiedField?: string;
+        };
+        prompt?: {
+            /**
+             * @default '{name} must have a value'
+             */
+            empty?: string;
+            /**
+             * @default '{name} must be checked'
+             */
+            checked?: string;
+            /**
+             * @default '{name} must be a valid e-mail'
+             */
+            email?: string;
+            /**
+             * @default '{name} must be a valid url'
+             */
+            url?: string;
+            /**
+             * @default '{name} is not formatted correctly'
+             */
+            regExp?: string;
+            /**
+             * @default '{name} must be an integer'
+             */
+            integer?: string;
+            /**
+             * @default '{name} must be a decimal number'
+             */
+            decimal?: string;
+            /**
+             * @default '{name} must be set to a number'
+             */
+                number?: string;
+            /**
+             * @default '{name} must be \'{ruleValue}\''
+             */
+                is?: string;
+            /**
+             * @default '{name} must be exactly \'{ruleValue}\''
+             */
+            isExactly?: string;
+            /**
+             * @default '{name} cannot be set to \'{ruleValue}\''
+             */
+            not?: string;
+            /**
+             * @default '{name} cannot be set to exactly \'{ruleValue}\''
+             */
+            notExactly?: string;
+            /**
+             * @default '{name} cannot contain \'{ruleValue}\''
+             */
+            contain?: string;
+            /**
+             * @default '{name} cannot contain exactly \'{ruleValue}\''
+             */
+            containExactly?: string;
+            /**
+             * @default '{name} must contain  \'{ruleValue}\''
+             */
+            doesntContain?: string;
+            /**
+             * @default '{name} must contain exactly \'{ruleValue}\''
+             */
+            doesntContainExactly?: string;
+            /**
+             * @default '{name} must be at least {ruleValue} characters'
+             */
+            minLength?: string;
+            /**
+             * @default '{name} must be at least {ruleValue} characters'
+             */
+            length?: string;
+            /**
+             * @default '{name} must be exactly {ruleValue} characters'
+             */
+            exactLength?: string;
+            /**
+             * @default '{name} cannot be longer than {ruleValue} characters'
+             */
+            maxLength?: string;
+            /**
+             * @default '{name} must match {ruleValue} field'
+             */
+            match?: string;
+            /**
+             * @default '{name} must have a different value than {ruleValue} field'
+             */
+            different?: string;
+            /**
+             * @default '{name} must be a valid credit card number'
+             */
+            creditCard?: string;
+            /**
+             * @default '{name} must have at least {ruleValue} choices'
+             */
+            minCount?: string;
+            /**
+             * @default '{name} must have exactly {ruleValue} choices'
+             */
+            exactCount?: string;
+            /**
+             * @default '{name} must have {ruleValue} or less choices'
+             */
+            maxCount?: string;
+        };
+
+        // endregion
+
+        // region Callbacks
+
+        /**
+         * Callback on each valid field
+         */
+        onValid?: (this: JQuery) => void;
+        /**
+         * Callback on each invalid field
+         */
+        onInvalid?: (this: JQuery) => void;
+        /**
+         * Callback if a form is all valid
+         */
+        onSuccess?: (this: JQuery, event: JQueryEventObject, fields: any) => void;
+        /**
+         * Callback if any form field is invalid
+         */
+        onFailure?: (this: JQuery, formErrors: string[], fields: any) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Selectors used to match functionality to DOM
+         */
+        selector?: {
+            /**
+             * @default '.error.message'
+             */
+            message?: string;
+            /**
+             * @default 'input, textarea, select'
+             */
+            field?: string;
+            /**
+             * @default '.field'
+             */
+            group?: string;
+            /**
+             * @default 'input'
+             */
+            input?: string;
+            /**
+             * @default '.prompt'
+             */
+            prompt?: string;
+            /**
+             * @default '.submit'
+             */
+            submit?: string;
+        };
+        /**
+         * HTML5 metadata attributes
+         */
+        metadata?: {
+            /**
+             * @default 'validate'
+             */
+            validate?: string;
+        };
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'active'
+             */
+            active?: string;
+            /**
+             * @default 'default'
+             */
+            placeholder?: string;
+            /**
+             * @default 'disabled'
+             */
+            disabled?: string;
+            /**
+             * @default 'visible'
+             */
+            visible?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    // endregion
+
+    // region Visibility
+
+    /**
+     * @see {@link http://semantic-ui.com/behaviors/visibility.html#/settings}
+     */
+    interface VisibilitySettings extends ComponentSettings {
+        // region Functionality
+
+        /**
+         * When set to false a callback will occur each time an element passes the threshold for a condition.
+         *
+         * @default true
+         */
+        once?: boolean;
+        /**
+         * When set to true a callback will occur anytime an element passes a condition not just immediately after the threshold is met.
+         *
+         * @default false
+         */
+        continuous?: boolean;
+        /**
+         * Set to image to load images when on screen. Set to fixed to add class name fixed when passed.
+         *
+         * @default false
+         */
+            type?: false | 'image' | 'fixed';
+        /**
+         * Whether visibility conditions should be checked immediately on init
+         *
+         * @default true
+         */
+        initialCheck?: boolean;
+        /**
+         * The scroll context visibility should use.
+         *
+         * @default 'window'
+         */
+        context?: Selector;
+        /**
+         * Whether visibility conditions should be checked on window load. This ensures that after images load content positions will be updated correctly.
+         *
+         * @default true
+         */
+        refreshOnLoad?: boolean;
+        /**
+         * Whether visibility conditions should be checked on window resize. Useful when content resizes causes continuous changes in position
+         *
+         * @default true
+         */
+        refreshOnResize?: boolean;
+        /**
+         * Whether visibility conditions should be checked on calls to refresh.
+         * These calls can be triggered from either resize, load or manually calling $('.foo').visibility('refresh')
+         *
+         * @default true
+         */
+        checkOnRefresh?: boolean;
+        /**
+         * Specify a z-index when using type: 'fixed'.
+         *
+         * @default 1
+         * @since 2.2
+         */
+        zIndex?: number;
+        /**
+         * Value that context scrollTop should be adjusted in pixels. Useful for making content appear below content fixed to the page.
+         *
+         * @default 0
+         */
+        offset?: number;
+        /**
+         * Whether element calculations should include its margin
+         *
+         * @default false
+         */
+        includeMargin?: boolean;
+        /**
+         * When set to an integer, scroll position will be debounced using this ms value. false will debounce with requestAnimationFrame.
+         *
+         * @default false
+         */
+        throttle?: false | number;
+        /**
+         * Whether to automatically refresh content when changes are made to the element's DOM subtree
+         *
+         * @default true
+         */
+        observeChanges?: boolean;
+        /**
+         * When using type: image allows you to specify transition when showing a loaded image
+         *
+         * @default false
+         */
+        transition?: false | string;
+        /**
+         * When using type: image allows you to specify transition duration
+         *
+         * @default 1000
+         */
+        duration?: number;
+
+        // endregion
+
+        // region Visibility Callbacks
+
+        /**
+         * Element's top edge has passed bottom of screen
+         */
+        onTopVisible?: (this: JQuery) => void;
+        /**
+         * Element's top edge has passed top of the screen
+         */
+        onTopPassed?: (this: JQuery) => void;
+        /**
+         * Element's bottom edge has passed bottom of screen
+         */
+        onBottomVisible?: (this: JQuery) => void;
+        /**
+         * Any part of an element is visible on screen
+         */
+        onPassing?: (this: JQuery) => void;
+        /**
+         * Element's bottom edge has passed top of screen
+         */
+        onBottomPassed?: (this: JQuery) => void;
+        /**
+         * Element's top edge has not passed bottom of screen
+         */
+        onTopVisibleReverse?: (this: JQuery) => void;
+        /**
+         * Element's top edge has not passed top of the screen
+         */
+        onTopPassedReverse?: (this: JQuery) => void;
+        /**
+         * Element's bottom edge has not passed bottom of screen
+         */
+        onBottomVisibleReverse?: (this: JQuery) => void;
+        /**
+         * Element's top has not passed top of screen but bottom has
+         */
+        onPassingReverse?: (this: JQuery) => void;
+        /**
+         * Element's bottom edge has not passed top of screen
+         */
+        onBottomPassedReverse?: (this: JQuery) => void;
+
+        // endregion
+
+        // region Image Callbacks
+
+        /**
+         * Occurs after an image has completed loading
+         *
+         * @since 2.2
+         */
+        onLoad?: (this: JQuery) => void;
+        /**
+         * Occurs after all img initialized at the same time have loaded.
+         *
+         * @since 2.2
+         */
+        onAllLoaded?: (this: JQuery) => void;
+
+        // endregion
+
+        // region Fixed Callbacks
+
+        /**
+         * Occurs after element has been assigned position fixed
+         *
+         * @since 2.2
+         */
+        onFixed?: (this: JQuery) => void;
+        /**
+         * Occurs after element has been removed from fixed position
+         *
+         * @since 2.2
+         */
+        onUnfixed?: (this: JQuery) => void;
+
+        // endregion
+
+        // region Utility Callbacks
+
+        /**
+         * Occurs each time an elements calculations are updated
+         */
+        onUpdate?: (this: JQuery, calculations: ElementCalculations) => void;
+        /**
+         * Occurs whenever element's visibility is refreshed
+         */
+        onRefresh?: (this: JQuery) => void;
+
+        // endregion
+
+        // region DOM Settings
+
+        /**
+         * Class names used to attach style to state
+         */
+        className?: {
+            /**
+             * @default 'fixed'
+             */
+            fixed?: string;
+        };
+
+        // endregion
+
+        // region Debug Settings
+
+        error?: {
+            /**
+             * @default 'The method you called is not defined.'
+             */
+            method?: string;
+        };
+
+        // endregion
+    }
+
+    interface ElementPosition {
+        fits: boolean;
+        offset: JQueryCoordinates;
+        width: number;
+        height: number;
+    }
+
+    interface ElementCalculations extends ElementPosition {
+        margin?: {
+            top: number;
+            bottom: number;
+        };
+        top: number;
+        bottom: number;
+
+        topVisible: boolean;
+        topPassed: boolean;
+        bottomVisible: boolean;
+        bottomPassed: boolean;
+        pixelsPassed: number;
+        percentagePassed: number;
+
+        onScreen: boolean;
+        passing: boolean;
+        offScreen: boolean;
+    }
+
+    interface ScreenCalculations {
+        top: number;
+        bottom: number;
+    }
+
+    interface ScreenSize {
+        height: number;
+    }
+
+    // endregion
+
+    // endregion
+}
diff --git a/semantic-ui/semantic-ui-tests.ts b/semantic-ui/semantic-ui-tests.ts
new file mode 100644
index 0000000000..f116507459
--- /dev/null
+++ b/semantic-ui/semantic-ui-tests.ts
@@ -0,0 +1,140 @@
+function test_Accordion() {
+    const selector = '.ui.accordion';
+    $(selector).accordion('refresh');
+    $(selector).accordion('open', 0);
+    $(selector).accordion('close others');
+    $(selector).accordion('close', 0);
+    $(selector).accordion('toggle', 0);
+    $(selector).accordion({
+        selector: {
+            trigger: '.title .icon'
+        }
+    });
+    $(selector).accordion();
+}
+test_Accordion();
+
+function test_Checkbox() {
+    const selector = '.ui.checkbox';
+    $(selector).checkbox({});
+    $(selector).checkbox();
+}
+test_Checkbox();
+
+function test_Dimmer() {
+    const selector = '.ui.dimmer';
+    $(selector).dimmer({});
+    $(selector).dimmer();
+}
+test_Dimmer();
+
+function test_Dropdown() {
+    const selector = '.ui.dropdown';
+    $(selector).dropdown({});
+    $(selector).dropdown();
+}
+test_Dropdown();
+
+function test_Embed() {
+    const selector = '.ui.embed';
+    $(selector).embed({});
+    $(selector).embed();
+}
+test_Embed();
+
+function test_Modal() {
+    const selector = '.ui.modal';
+    $(selector).modal({});
+    $(selector).modal();
+}
+test_Modal();
+
+function test_Nag() {
+    const selector = '.ui.nag';
+    $(selector).nag({});
+}
+test_Nag();
+
+function test_Popup() {
+    const selector = '.ui.popup';
+    $(selector).popup({});
+    $(selector).popup();
+}
+test_Popup();
+
+function test_Progress() {
+    const selector = '.ui.progress';
+    $(selector).progress({});
+    $(selector).progress();
+}
+test_Progress();
+
+function test_Rating() {
+    const selector = '.ui.rating';
+    $(selector).rating({});
+    $(selector).rating();
+}
+test_Rating();
+
+function test_Search() {
+    const selector = '.ui.search';
+    $(selector).search({});
+    $(selector).search();
+}
+test_Search();
+
+function test_Shape() {
+    const selector = '.ui.shape';
+    $(selector).shape({});
+    $(selector).shape();
+}
+test_Shape();
+
+function test_Sidebar() {
+    const selector = '.ui.sidebar';
+    $(selector).sidebar({});
+    $(selector).sidebar();
+}
+test_Sidebar();
+
+function test_Sticky() {
+    const selector = '.ui.sticky';
+    $(selector).sticky({});
+    $(selector).sticky();
+}
+test_Sticky();
+
+function test_Tab() {
+    const selector = '.ui.tab';
+    $(selector).tab({});
+    $(selector).tab();
+}
+test_Tab();
+
+function test_Transition() {
+    const selector = '.ui.transition';
+    $(selector).transition({});
+    $(selector).transition();
+}
+test_Transition();
+
+function test_Api() {
+    const selector = '.ui.api';
+    $(selector).api({});
+    $(selector).api();
+}
+test_Api();
+
+function test_Form() {
+    const selector = '.ui.form';
+    $(selector).form({});
+    $(selector).form();
+}
+test_Form();
+
+function test_Visibility() {
+    const selector = '.ui.visibility';
+    $(selector).visibility({});
+    $(selector).visibility();
+}
+test_Visibility();
diff --git a/semantic-ui/tsconfig.json b/semantic-ui/tsconfig.json
new file mode 100644
index 0000000000..f57f321023
--- /dev/null
+++ b/semantic-ui/tsconfig.json
@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es6",
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "baseUrl": "../",
+    "typeRoots": [
+      "../"
+    ],
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+    "index.d.ts",
+    "semantic-ui-tests.ts"
+  ]
+}
diff --git a/semantic-ui/tslint.json b/semantic-ui/tslint.json
new file mode 100644
index 0000000000..ec365f164b
--- /dev/null
+++ b/semantic-ui/tslint.json
@@ -0,0 +1,3 @@
+{
+  "extends": "../tslint.json"
+}

From 748431211f8bc7306c1384f44f4b9bbe05222cee Mon Sep 17 00:00:00 2001
From: Shun <shuntksh@gmail.com>
Date: Wed, 25 Jan 2017 23:37:18 -0800
Subject: [PATCH 33/87] Add typing files for forever-monitor 1.7

---
 forever-monitor/forever-monitor-tests.ts | 15 +++++++++++++++
 forever-monitor/index.d.ts               | 18 +++++++++---------
 2 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/forever-monitor/forever-monitor-tests.ts b/forever-monitor/forever-monitor-tests.ts
index e69de29bb2..f679c4704a 100644
--- a/forever-monitor/forever-monitor-tests.ts
+++ b/forever-monitor/forever-monitor-tests.ts
@@ -0,0 +1,15 @@
+// Test from https://github.com/foreverjs/forever-monitor
+
+import * as forever from "forever-monitor";
+
+const child = new (forever.Monitor)('your-filename.js', {
+  max: 3,
+  silent: true,
+  args: []
+});
+
+child.on('exit', function() {
+  console.log('your-filename.js has exited after 3 restarts');
+});
+
+child.start();
diff --git a/forever-monitor/index.d.ts b/forever-monitor/index.d.ts
index b22905cae2..58c32ec5e6 100644
--- a/forever-monitor/index.d.ts
+++ b/forever-monitor/index.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for forever-monitor 1.7
 // Project: https://github.com/nodejitsu/forever-monitor#readme
-// Definitions by: My Self <https://github.com/me>
+// Definitions by: Shun Takahashi <https://github.com/shuntksh>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 /// <reference types="node" />
 
@@ -53,44 +53,44 @@ export declare class Monitor extends NodeJS.EventEmitter {
      * @description Start the process that this instance is configured for
      * @param [restart] - Value indicating whether this is a restart.
      */
-    public start(restart?: boolean): this;
+    start(restart?: boolean): this;
 
     /**
      * @description Tries to spawn the target Forever child process.
      */
-    public trySpawn(): boolean;
+    trySpawn(): boolean;
 
     /**
      * @description Restarts the target script associated with this instance.
      */
-    public restart(): this;
+    restart(): this;
 
     /**
      * @description Stops the target script associated with this instance. Prevents it from auto-respawning
      */
-    public stop(): this;
+    stop(): this;
 
     /**
      * @description Kills the ChildProcess object associated with this instance
      * @param [forceStop] - Value indicating whether short circuit forever auto-restart
      */
-    public kill(forceStop?: boolean): this;
+    kill(forceStop?: boolean): this;
 
     /**
      * @description Sends a message to a forked ChildProcess object associated with this instance
      */
-    public send(msg?: any): this;
+    send(msg?: any): this;
 
     /**
      * respond with JSON for this instance
      */
-    public toString(): string;
+    toString(): string;
 
     /**
      * @param command - Command string to parse
      * @param args - Additional default arguments
      */
-    public parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
+    parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
 }
 
 interface forever {

From e297d2677fb7bb82e6c06ef4a34532c8d65bcb0b Mon Sep 17 00:00:00 2001
From: york yao <yaoao12306@outlook.com>
Date: Thu, 26 Jan 2017 19:20:44 +0800
Subject: [PATCH 34/87] fix name, class to interface, var to const, enable
 strictNullChecks

---
 node-zookeeper-client/index.d.ts                   |  6 +++---
 .../node-zookeeper-client-tests.ts                 | 14 +++++++-------
 node-zookeeper-client/tsconfig.json                |  2 +-
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/node-zookeeper-client/index.d.ts b/node-zookeeper-client/index.d.ts
index cb9979e9f4..a85d14b7cc 100644
--- a/node-zookeeper-client/index.d.ts
+++ b/node-zookeeper-client/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Jasmine 2.5
+// Type definitions for node-zookeeper-client 0.2
 // Project: https://github.com/alexguan/node-zookeeper-client
 // Definitions by: York Yao <https://github.com/plantain-00/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -72,7 +72,7 @@ export class Event {
     getPath(): string;
 }
 
-export class Transaction {
+interface Transaction {
     create(path: string, dataOrAclsOrmode1?: Buffer | ACL[] | number, dataOrAclsOrmode2?: Buffer | ACL[] | number, dataOrAclsOrmode3?: Buffer | ACL[] | number): this;
     setData(path: string, data: Buffer | null, version?: number): this;
     check(path: string, version?: number): this;
@@ -80,7 +80,7 @@ export class Transaction {
     commit(callback: (error: Error | Exception, results: any) => void): void;
 }
 
-export class Client extends EventEmitter {
+interface Client extends EventEmitter {
     connect(): void;
     close(): void;
     create(path: string, callback: (error: Error | Exception, path: string) => void): void;
diff --git a/node-zookeeper-client/node-zookeeper-client-tests.ts b/node-zookeeper-client/node-zookeeper-client-tests.ts
index 19cca8628b..91c434bafa 100644
--- a/node-zookeeper-client/node-zookeeper-client-tests.ts
+++ b/node-zookeeper-client/node-zookeeper-client-tests.ts
@@ -1,8 +1,8 @@
 import * as zookeeper from "node-zookeeper-client";
 
 {
-    var client = zookeeper.createClient('localhost:2181');
-    var path = process.argv[2];
+    const client = zookeeper.createClient('localhost:2181');
+    const path = process.argv[2];
 
     client.once('connected', function () {
         console.log('Connected to the server.');
@@ -44,8 +44,8 @@ function listChildren(client: zookeeper.Client, path: string) {
 }
 
 {
-    var client = zookeeper.createClient('localhost:2181');
-    var path = process.argv[2];
+    const client = zookeeper.createClient('localhost:2181');
+    const path = process.argv[2];
 
     client.once('connected', function () {
         console.log('Connected to ZooKeeper.');
@@ -55,7 +55,7 @@ function listChildren(client: zookeeper.Client, path: string) {
     client.connect();
 }
 
-var client = zookeeper.createClient(
+const client = zookeeper.createClient(
     'localhost:2181/test',
     { sessionTimeout: 10000 }
 );
@@ -188,12 +188,12 @@ var client = zookeeper.createClient(
 }
 
 {
-    var state = client.getState();
+    const state = client.getState();
     console.log('Current state is: %s', state);
 }
 
 {
-    var id = client.getSessionId();
+    const id = client.getSessionId();
     console.log('Session id is: %s', id.toString('hex'));
 }
 
diff --git a/node-zookeeper-client/tsconfig.json b/node-zookeeper-client/tsconfig.json
index d93291d45b..1f5ffdedf8 100644
--- a/node-zookeeper-client/tsconfig.json
+++ b/node-zookeeper-client/tsconfig.json
@@ -6,7 +6,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"

From c4cee4d79eb3b6d8eb5e99424913ea5af103ec10 Mon Sep 17 00:00:00 2001
From: york yao <yaoao12306@outlook.com>
Date: Thu, 26 Jan 2017 20:01:15 +0800
Subject: [PATCH 35/87] fix wrong CreateMode value

---
 node-zookeeper-client/index.d.ts                     | 2 +-
 node-zookeeper-client/node-zookeeper-client-tests.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/node-zookeeper-client/index.d.ts b/node-zookeeper-client/index.d.ts
index a85d14b7cc..227ebd45ad 100644
--- a/node-zookeeper-client/index.d.ts
+++ b/node-zookeeper-client/index.d.ts
@@ -132,7 +132,7 @@ export function createClient(connectionString: string, options?: Partial<Option>
 export const CreateMode: {
     PERSISTENT: number,
     PERSISTENT_SEQUENTIAL: number,
-    EPHEMERA: number,
+    EPHEMERAL: number,
     EPHEMERAL_SEQUENTIAL: number,
 };
 
diff --git a/node-zookeeper-client/node-zookeeper-client-tests.ts b/node-zookeeper-client/node-zookeeper-client-tests.ts
index 91c434bafa..71f2267878 100644
--- a/node-zookeeper-client/node-zookeeper-client-tests.ts
+++ b/node-zookeeper-client/node-zookeeper-client-tests.ts
@@ -64,7 +64,7 @@ const client = zookeeper.createClient(
     client.create(
         '/test/demo',
         new Buffer('data'),
-        zookeeper.CreateMode.EPHEMERA,
+        zookeeper.CreateMode.EPHEMERAL,
         function (error: Error, path) {
             if (error) {
                 console.log(error.stack);

From e13d67a3d0fc3afc7aa17bcc7dacd63c2aa3e20f Mon Sep 17 00:00:00 2001
From: Leonard Thieu <leonard.thieu@gmail.com>
Date: Thu, 26 Jan 2017 07:11:56 -0500
Subject: [PATCH 36/87] Move tslint rule to tslint.json.

---
 semantic-ui/index.d.ts  | 2 --
 semantic-ui/tslint.json | 5 ++++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/semantic-ui/index.d.ts b/semantic-ui/index.d.ts
index 0c8ddda9be..96a292bcce 100644
--- a/semantic-ui/index.d.ts
+++ b/semantic-ui/index.d.ts
@@ -5,8 +5,6 @@
 
 /// <reference types="jquery" />
 
-// tslint:disable:unified-signatures
-
 interface JQuery {
     // TODO: Do all modules have a 'setting' behavior?
 
diff --git a/semantic-ui/tslint.json b/semantic-ui/tslint.json
index ec365f164b..25440fc88b 100644
--- a/semantic-ui/tslint.json
+++ b/semantic-ui/tslint.json
@@ -1,3 +1,6 @@
 {
-  "extends": "../tslint.json"
+  "extends": "../tslint.json",
+  "rules": {
+    "unified-signatures": false
+  }
 }

From 5bc6bd90add66f6ba740837a1413ea2d3d4a2620 Mon Sep 17 00:00:00 2001
From: Leonard Thieu <leonard.thieu@gmail.com>
Date: Thu, 26 Jan 2017 07:39:15 -0500
Subject: [PATCH 37/87] Fix typo.

---
 semantic-ui/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/semantic-ui/index.d.ts b/semantic-ui/index.d.ts
index 96a292bcce..71a4868e3e 100644
--- a/semantic-ui/index.d.ts
+++ b/semantic-ui/index.d.ts
@@ -2989,7 +2989,7 @@ declare namespace SemanticUI {
          */
         onHidden?: (this: JQuery, $module: JQuery) => void;
         /**
-         * Callback after popup cannot be plaed on screen
+         * Callback after popup cannot be placed on screen
          */
         onUnplaceable?: (this: JQuery, $module: JQuery) => void;
 

From 273f1453129c1bc93859e15254cf9bc6ce9d1363 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:03:48 +0200
Subject: [PATCH 38/87] Add Steed typings

---
 package.json         |   2 +-
 steed/index.d.ts     |  56 +++++++
 steed/steed-tests.ts | 353 +++++++++++++++++++++++++++++++++++++++++++
 steed/tsconfig.json  |  20 +++
 tslint-common.json   |  37 +++++
 tslint.json          |  14 +-
 6 files changed, 480 insertions(+), 2 deletions(-)
 create mode 100644 steed/index.d.ts
 create mode 100644 steed/steed-tests.ts
 create mode 100644 steed/tsconfig.json
 create mode 100644 tslint-common.json

diff --git a/package.json b/package.json
index a9b9625069..a41b9ddc69 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,6 @@
     "test": "node node_modules/types-publisher/bin/tester/test.js --run-from-definitely-typed --nProcesses 1"
   },
   "devDependencies": {
-    "types-publisher": "Microsoft/types-publisher#production"
+    "": "Microsoft/types-publisher#production"
   }
 }
diff --git a/steed/index.d.ts b/steed/index.d.ts
new file mode 100644
index 0000000000..3bad4d1ab1
--- /dev/null
+++ b/steed/index.d.ts
@@ -0,0 +1,56 @@
+// Type definitions for steed 1.1
+// Project: https://github.com/mcollina/steed#readme
+// Definitions by: Paul Isache <https://github.com/Paul-Isache>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface Dictionary<T> { [key: string]: T }
+interface ErrorCallback<T> { (err?: T): void }
+
+interface SteedResultCallback<T, E> { (err: E, result: T): void }
+interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void }
+interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void }
+
+interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void }
+interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void }
+interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void }
+interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void }
+
+interface SteedQueue<T> {
+    push<E>(task: T, callback?: ErrorCallback<E>): void;
+    push<E>(task: T, callback?: SteedResultCallback<T, 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;
+    pause(): void;
+    resume(): void;
+    idle(): boolean;
+    length(): number;
+    kill(): void;
+    concurrency: number;
+    drain: () => any;
+    empty: () => any;
+    saturated: () => any;
+}
+
+interface Steed {
+    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+    series<T, E>(tasks: SteedFunction<T, E>[], callback?: SteedResultArrayCallback<T, E>): void;
+    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+    each<T, E>(arr: T[], iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+    each<T, E>(arr: Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+    eachSeries: typeof steed.each;
+    map<T, R, E>(arr: T[], iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+    map<T, R, E>(arr: Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+    mapSeries: typeof steed.map;
+    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>
+}
+
+
+declare const steed: Steed
+
+declare module "steed" {
+    export = steed
+}
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
new file mode 100644
index 0000000000..679c597b08
--- /dev/null
+++ b/steed/steed-tests.ts
@@ -0,0 +1,353 @@
+/// <reference types="node" />
+
+import fs = require("fs");
+import process = require("process");
+
+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() { }
+
+steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
+steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
+
+
+steed.parallel([
+    function () { },
+    function () { }
+], callback);
+
+steed.series([
+    function () { },
+    function () { }
+]);
+
+var data: any[] = [];
+function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (err, results) {
+    console.log(results);
+});
+
+var openFiles = ['file1', 'file2'];
+
+var saveFile = function (file:string,cb:(err:Error)=>void) { }
+steed.each(openFiles, saveFile, function (err:Error) { });
+steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+
+// Control Flow //
+
+steed.series([
+    function (callback) {
+        callback(undefined, 'one');
+    },
+    function (callback) {
+        callback(undefined, 'two');
+    },
+],
+function (err, results) { });
+
+steed.series<string,Error>([
+    function (callback) {
+        callback(undefined, 'one');
+    },
+    function (callback) {
+        callback(undefined, 'two');
+    },
+],
+function (err, results) { });
+
+steed.series({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+function (err, results) { });
+
+steed.series<number,Error>({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+function (err, results) { });
+
+steed.parallel([
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'one');
+        }, 200);
+    },
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'two');
+        }, 100);
+    },
+],
+function (err, results) { });
+
+steed.parallel<string,Error>([
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'one');
+        }, 200);
+    },
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'two');
+        }, 100);
+    },
+],
+function (err, results) { });
+
+
+steed.parallel({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+function (err, results) { });
+
+steed.parallel<number,Error>({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+    function (err, results) { });
+
+function whileFn(callback: any) {
+    count++;
+    setTimeout(callback, 1000);
+}
+
+function whileTest() { return count < 5; }
+var count = 0;
+
+steed.waterfall([
+    function (callback: any) {
+        callback(null, 'one', 'two');
+    },
+    function (arg1: any, arg2: any, callback: any) {
+        callback(null, 'three');
+    },
+    function (arg1: any, callback: any) {
+        callback(null, 'done');
+    }
+], function (err, result) { });
+
+
+var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+    console.log('hello ' + task.name);
+    callback();
+}, 2);
+
+
+q.drain = function () {
+    console.log('all items have been processed');
+}
+
+q.push({ name: 'foo' });
+
+q.push({ name: 'bar' }, function (err) {
+    console.log('finished processing bar');
+});
+
+q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+    console.log('finished processing bar');
+});
+
+q.unshift({ name: 'foo' });
+
+q.unshift({ name: 'bar' }, function (err) {
+    console.log('finished processing bar');
+});
+
+q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+    console.log('finished processing bar');
+});
+
+var qLength : number = q.length();
+var qIsIdle : boolean = q.idle();
+
+q.saturated = function() {
+    console.log('queue is saturated.');
+}
+
+q.empty = function() {
+    console.log('queue is empty.');
+}
+
+q.drain = function() {
+    console.log('queue was drained.');
+}
+
+q.pause();
+q.resume();
+q.kill();
+
+// tests for strongly typed tasks
+var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+    console.log('Task: ' + task);
+    callback();
+}, 1);
+
+q2.push('task1');
+
+q2.push('task2', function (error) {
+    console.log('Finished tasks');
+});
+
+q2.push(['task3', 'task4', 'task5'], function (error) {
+    console.log('Finished tasks');
+});
+
+q2.unshift('task1');
+
+q2.unshift('task2', function (error) {
+    console.log('Finished tasks');
+});
+
+q2.unshift(['task3', 'task4', 'task5'], function (error) {
+    console.log('Finished tasks');
+});
+
+
+var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
+    console.log('hello ' + level);
+    callback(null, level+1);
+});
+
+aq.push(1, function (err : Error, newLevel : number) {
+    console.log('finished processing bar' + newLevel);
+});
+
+
+steed.parallel([
+    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback) { }
+],
+function (err:Error,results:Array<string>) {
+    steed.series([
+        function (callback) { },
+        function email_link(callback) { }
+    ]);
+});
+
+steed.parallel([
+    function (callback) {
+        fs.writeFile('testfile1', 'test1', callback);
+    },
+    function (callback) {
+        fs.writeFile('testfile2', 'test2', callback);
+    },
+]);
+
+// each
+
+steed.each<number,Error>({
+    "a": 1,
+    "b": 2
+}, function(val: number, next: ErrorCallback<Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.each: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("steed.each: done.");
+
+});
+
+steed.eachSeries<number, Error>({
+    "a": 1,
+    "b": 2
+}, function(val: number, next: ErrorCallback<Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.eachSeries: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("steed.eachSeries: done.");
+
+});
+
+// map
+
+steed.map<number, string, Error>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: SteedResultCallback<string, Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.map: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("steed.map: done with results", results);
+
+});
+
+steed.mapSeries<number, string, Error>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: SteedResultCallback<string, Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.mapSeries: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("steed.mapSeries: done with results", results);
+
+});
\ No newline at end of file
diff --git a/steed/tsconfig.json b/steed/tsconfig.json
new file mode 100644
index 0000000000..ec8377c527
--- /dev/null
+++ b/steed/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "steed-tests.ts"
+    ]
+}
diff --git a/tslint-common.json b/tslint-common.json
new file mode 100644
index 0000000000..94ad064cab
--- /dev/null
+++ b/tslint-common.json
@@ -0,0 +1,37 @@
+{
+	"extends": "tslint:latest",
+	"rulesDirectory": [
+		"bin/tslint"
+	],
+	"rules": {
+		// Custom rules
+		"dt-header": true,
+		"export-just-namespace": true,
+		"forbidden-types": true,
+		"no-dead-reference": true,
+		"no-parent-references": true,
+		"no-public": true,
+		"no-reference-import": true,
+		"no-single-declare-module": true,
+		"unified-signatures": true,
+		"void-return": true,
+
+		"array-type": [true, "array-simple"],
+		"arrow-parens": false,
+		"callable-types": true,
+		"interface-name": [true, "never-prefix"],
+		"interface-over-type-literal": true,
+		"max-classes-per-file": false,
+		"member-access": false,
+		"member-ordering": false,
+		"no-bitwise": false,
+		"no-console": false,
+		"no-empty-interface": true,
+		"no-namespace": false,
+		"object-literal-sort-keys": false,
+		"one-variable-per-declaration": false,
+		"ordered-imports": false,
+		"switch-default": false,
+		"trailing-comma": false
+    }
+}
\ No newline at end of file
diff --git a/tslint.json b/tslint.json
index 6b04ae7f36..7a4e7686db 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1 +1,13 @@
-{ "extends": "./node_modules/types-publisher/tslint-definitions.json" }
\ No newline at end of file
+{
+	"extends": "./tslint-common.json",
+	"rules": {
+		"forin": false,
+		"indent": [true, "tabs"],
+		"max-line-length": [true, 150],
+		"no-var-requires": false,
+		"one-line": false,
+		// https://github.com/palantir/tslint/issues/2001
+		"space-before-function-paren": [true, {"asyncArrow": "always"}],
+		"variable-name": false
+	}
+}
\ No newline at end of file

From 08015645c72a91a940e2368b40e7cceeef2500da Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:07:01 +0200
Subject: [PATCH 39/87] Add Steed typings

---
 tslint-common.json | 37 -------------------------------------
 tslint.json        | 14 +-------------
 2 files changed, 1 insertion(+), 50 deletions(-)
 delete mode 100644 tslint-common.json

diff --git a/tslint-common.json b/tslint-common.json
deleted file mode 100644
index 94ad064cab..0000000000
--- a/tslint-common.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-	"extends": "tslint:latest",
-	"rulesDirectory": [
-		"bin/tslint"
-	],
-	"rules": {
-		// Custom rules
-		"dt-header": true,
-		"export-just-namespace": true,
-		"forbidden-types": true,
-		"no-dead-reference": true,
-		"no-parent-references": true,
-		"no-public": true,
-		"no-reference-import": true,
-		"no-single-declare-module": true,
-		"unified-signatures": true,
-		"void-return": true,
-
-		"array-type": [true, "array-simple"],
-		"arrow-parens": false,
-		"callable-types": true,
-		"interface-name": [true, "never-prefix"],
-		"interface-over-type-literal": true,
-		"max-classes-per-file": false,
-		"member-access": false,
-		"member-ordering": false,
-		"no-bitwise": false,
-		"no-console": false,
-		"no-empty-interface": true,
-		"no-namespace": false,
-		"object-literal-sort-keys": false,
-		"one-variable-per-declaration": false,
-		"ordered-imports": false,
-		"switch-default": false,
-		"trailing-comma": false
-    }
-}
\ No newline at end of file
diff --git a/tslint.json b/tslint.json
index 7a4e7686db..6b04ae7f36 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1,13 +1 @@
-{
-	"extends": "./tslint-common.json",
-	"rules": {
-		"forin": false,
-		"indent": [true, "tabs"],
-		"max-line-length": [true, 150],
-		"no-var-requires": false,
-		"one-line": false,
-		// https://github.com/palantir/tslint/issues/2001
-		"space-before-function-paren": [true, {"asyncArrow": "always"}],
-		"variable-name": false
-	}
-}
\ No newline at end of file
+{ "extends": "./node_modules/types-publisher/tslint-definitions.json" }
\ No newline at end of file

From 43e36a1ce921c55227cab6b4535ab6e76f869df2 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:17:38 +0200
Subject: [PATCH 40/87] Add Steed typings

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index a41b9ddc69..a9b9625069 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,6 @@
     "test": "node node_modules/types-publisher/bin/tester/test.js --run-from-definitely-typed --nProcesses 1"
   },
   "devDependencies": {
-    "": "Microsoft/types-publisher#production"
+    "types-publisher": "Microsoft/types-publisher#production"
   }
 }

From 5e7b7a31df67ec8954ee8723af78b7608ac9e52c Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:23:19 +0200
Subject: [PATCH 41/87] Pino - Modify interface for formatter pretty option -
 https://github.com/pinojs/pino/blob/master/docs/API.md#user-content-parameters-1

---
 pino/index.d.ts | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/pino/index.d.ts b/pino/index.d.ts
index 8e8a09c2f9..8d2b687f0b 100644
--- a/pino/index.d.ts
+++ b/pino/index.d.ts
@@ -10,9 +10,18 @@ import stream = require('stream');
 declare function P(optionsOrStream?: P.LoggerOptions | stream.Writable | stream.Duplex | stream.Transform): P.Logger;
 declare function P(options: P.LoggerOptions, stream: stream.Writable | stream.Duplex | stream.Transform): P.Logger;
 
+interface IPinoLog {
+    pid: number
+    hostname: string
+    level: number
+    time: string
+    msg: string
+    v: number
+}
+
 declare namespace P {
 
-    function pretty(opts?: {timeTransOnly?: boolean, levelFirst?: boolean, formatter?: (str: string) => void}): stream.Transform;
+    function pretty(opts?: {timeTransOnly?: boolean, levelFirst?: boolean, formatter?: (log: IPinoLog) => string}): stream.Transform;
 
     type Level = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
     interface Headers {

From 413b64448a9a0554050d27ee9acdb2fd5878c703 Mon Sep 17 00:00:00 2001
From: Bogdan Ursache <bogdan.ursache@thinslices.com>
Date: Thu, 26 Jan 2017 15:47:15 +0200
Subject: [PATCH 42/87] steed - Fix linting errors

---
 steed/index.d.ts     | 40 +++++++++++++++++-----------------------
 steed/steed-tests.ts | 16 ++++++++--------
 2 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index 3bad4d1ab1..f88669e92c 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,24 +3,21 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T }
-interface ErrorCallback<T> { (err?: T): void }
+interface Dictionary<T> { [key: string]: T; }
+interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void }
+interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void }
+interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
 
 interface SteedQueue<T> {
-    push<E>(task: T, callback?: ErrorCallback<E>): void;
-    push<E>(task: T, callback?: SteedResultCallback<T, 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;
+    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
     pause(): void;
     resume(): void;
     idle(): boolean;
@@ -35,22 +32,19 @@ interface SteedQueue<T> {
 interface Steed {
     parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
     parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: SteedFunction<T, E>[], callback?: SteedResultArrayCallback<T, E>): void;
+    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
     series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
     waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[], iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    each<T, E>(arr: Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
     eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[], iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    map<T, R, E>(arr: Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
     mapSeries: typeof steed.map;
     queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>
+    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
 }
 
-
-declare const steed: Steed
+declare const steed: Steed;
 
 declare module "steed" {
-    export = steed
+    export = steed;
 }
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 679c597b08..729e59472f 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -240,14 +240,14 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
 });
 
 
-var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-    console.log('hello ' + level);
-    callback(null, level+1);
-});
-
-aq.push(1, function (err : Error, newLevel : number) {
-    console.log('finished processing bar' + newLevel);
-});
+// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
+//     console.log('hello ' + level);
+//     callback(null, level+1);
+// });
+//
+// aq.push(1, function (err : Error, newLevel : number) {
+//     console.log('finished processing bar' + newLevel);
+// });
 
 
 steed.parallel([

From dd01b06b7c193e818936614c27ecb771a06dcbe2 Mon Sep 17 00:00:00 2001
From: Andy Hanson <anhans@microsoft.com>
Date: Thu, 26 Jan 2017 06:37:59 -0800
Subject: [PATCH 43/87] Clarify why authors are mentioned.

---
 ISSUE_TEMPLATE.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
index 252df5994f..4078b4808b 100644
--- a/ISSUE_TEMPLATE.md
+++ b/ISSUE_TEMPLATE.md
@@ -1,4 +1,5 @@
 - [ ] I tried using the `@types/xxxx` package and had problems.
 - [ ] I tried using the latest stable version of tsc. https://www.npmjs.com/package/typescript
 - [ ] I have a question that is inappropriate for [StackOverflow](https://stackoverflow.com/).  (Please ask any appropriate questions there).
-- The authors (see `Definitions by:` in `index.d.ts`) are cc/ @....
+- [ ] [Mention](https://github.com/blog/821-mention-somebody-they-re-notified) the authors (see `Definitions by:` in `index.d.ts`) so they can respond.
+  - Authors: @....

From 09a0be6faf004e0515a38eef637115f2eb8b73ce Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Thu, 26 Jan 2017 18:12:23 +0100
Subject: [PATCH 44/87] Keep old typings for v16

---
 jest/v16/index.d.ts    | 303 +++++++++++++++++++++++++++++++++
 jest/v16/jest-tests.ts | 369 +++++++++++++++++++++++++++++++++++++++++
 jest/v16/tsconfig.json |  23 +++
 3 files changed, 695 insertions(+)
 create mode 100644 jest/v16/index.d.ts
 create mode 100644 jest/v16/jest-tests.ts
 create mode 100644 jest/v16/tsconfig.json

diff --git a/jest/v16/index.d.ts b/jest/v16/index.d.ts
new file mode 100644
index 0000000000..f376ea5bcc
--- /dev/null
+++ b/jest/v16/index.d.ts
@@ -0,0 +1,303 @@
+// Type definitions for Jest 16.0.0
+// Project: http://facebook.github.io/jest/
+// Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare var beforeAll: jest.Lifecycle;
+declare var beforeEach: jest.Lifecycle;
+declare var afterAll: jest.Lifecycle;
+declare var afterEach: jest.Lifecycle;
+declare var describe: jest.Describe;
+declare var fdescribe: jest.Describe;
+declare var xdescribe: jest.Describe;
+declare var it: jest.It;
+declare var fit: jest.It;
+declare var xit: jest.It;
+declare var test: jest.It;
+declare var xtest: jest.It;
+
+declare function expect(actual: any): jest.Matchers;
+
+interface NodeRequire {
+    /** Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not. */
+    requireActual(moduleName: string): any;
+    /** Returns a mock module instead of the actual module, bypassing all checks on whether the module should be required normally or not. */
+    requireMock(moduleName: string): any;
+}
+
+declare namespace jest {
+    function addMatchers(matchers: jasmine.CustomMatcherFactories): typeof jest;
+    /** Disables automatic mocking in the module loader. */
+    function autoMockOff(): typeof jest;
+    /** Enables automatic mocking in the module loader. */
+    function autoMockOn(): typeof jest;
+    /** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
+    function clearAllMocks(): typeof jest;
+    /** Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future. */
+    function clearAllTimers(): typeof jest;
+    /** Indicates that the module system should never return a mocked version of the specified module, including all of the specificied module's dependencies. */
+    function deepUnmock(moduleName: string): typeof jest;
+    /** Disables automatic mocking in the module loader. */
+    function disableAutomock(): typeof jest;
+    /** Mocks a module with an auto-mocked version when it is being required. */
+    function doMock(moduleName: string): typeof jest;
+    /** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
+    function dontMock(moduleName: string): typeof jest;
+    /** Enables automatic mocking in the module loader. */
+    function enableAutomock(): typeof jest;
+    /** Creates a mock function. Optionally takes a mock implementation. */
+    function fn<T>(implementation?: Function): Mock<T>;
+    /** Use the automatic mocking system to generate a mocked version of the given module. */
+    function genMockFromModule<T>(moduleName: string): T;
+    /** Returns whether the given function is a mock function. */
+    function isMockFunction(fn: any): fn is Mock<any>;
+    /** Mocks a module with an auto-mocked version when it is being required. */
+    function mock(moduleName: string, factory?: any, options?: MockOptions): typeof jest;
+    /** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
+    function resetModuleRegistry(): typeof jest;
+    /** Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests. */
+    function resetModules(): typeof jest;
+    /** Exhausts tasks queued by setImmediate(). */
+    function runAllImmediates(): typeof jest;
+    /** Exhausts the micro-task queue (usually interfaced in node via process.nextTick). */
+    function runAllTicks(): typeof jest;
+    /** Exhausts the macro-task queue (i.e., all tasks queued by setTimeout() and setInterval()). */
+    function runAllTimers(): typeof jest;
+    /** Executes only the macro-tasks that are currently pending (i.e., only the tasks that have been queued by setTimeout() or setInterval() up to this point).
+     * If any of the currently pending macro-tasks schedule new macro-tasks, those new tasks will not be executed by this call. */
+    function runOnlyPendingTimers(): typeof jest;
+    /** Executes only the macro task queue (i.e. all tasks queued by setTimeout() or setInterval() and setImmediate()). */
+    function runTimersToTime(msToRun: number): typeof jest;
+    /** Explicitly supplies the mock object that the module system should return for the specified module. */
+    function setMock<T>(moduleName: string, moduleExports: T): typeof jest;
+    /** Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module). */
+    function unmock(moduleName: string): typeof jest;
+    /** Instructs Jest to use fake versions of the standard timer functions. */
+    function useFakeTimers(): typeof jest;
+    /** Instructs Jest to use the real versions of the standard timer functions. */
+    function useRealTimers(): typeof jest;
+
+    interface MockOptions {
+        virtual?: boolean;
+    }
+
+    interface EmptyFunction {
+        (): void;
+    }
+
+    interface DoneCallback {
+        (...args: any[]): any
+        fail(error?: string | { message: string }): any;
+    }
+
+    interface ProvidesCallback {
+        (cb: DoneCallback): any;
+    }
+
+    interface Lifecycle {
+        (fn: ProvidesCallback): any;
+    }
+
+    interface It {
+        (name: string, fn?: ProvidesCallback): void;
+        only: It;
+        skip: It;
+        concurrent: It;
+    }
+
+    interface Describe {
+        (name: string, fn: EmptyFunction): void
+        only: Describe;
+        skip: Describe;
+    }
+
+    interface Matchers {
+        not: Matchers;
+        lastCalledWith(...args: any[]): void;
+        toBe(expected: any): void;
+        toBeCalled(): void;
+        toBeCalledWith(...args: any[]): void;
+        toBeCloseTo(expected: number, delta: number): void;
+        toBeDefined(): void;
+        toBeFalsy(): void;
+        toBeGreaterThan(expected: number): void;
+        toBeGreaterThanOrEqual(expected: number): void;
+        toBeInstanceOf(expected: any): void
+        toBeLessThan(expected: number): void;
+        toBeLessThanOrEqual(expected: number): void;
+        toBeNull(): void;
+        toBeTruthy(): void;
+        toBeUndefined(): void;
+        toContain(expected: any): void;
+        toContainEqual(expected: any): void;
+        toEqual(expected: any): void;
+        toHaveBeenCalled(): boolean;
+        toHaveBeenCalledTimes(expected: number): boolean;
+        toHaveBeenCalledWith(...params: any[]): boolean;
+        toHaveBeenLastCalledWith(...params: any[]): boolean;
+        toMatch(expected: string | RegExp): void;
+        toMatchObject(expected: {}): void;
+        toMatchSnapshot(): void;
+        toThrow(): void;
+        toThrowError(error?: string | Constructable | RegExp): void;
+        toThrowErrorMatchingSnapshot(): void;
+    }
+
+    interface Constructable {
+        new (...args: any[]): any
+    }
+
+    interface Mock<T> extends Function {
+        new (): T;
+        (...args: any[]): any;
+        mock: MockContext<T>;
+        mockClear(): void;
+        mockReset(): void;
+        mockImplementation(fn: Function): Mock<T>;
+        mockImplementationOnce(fn: Function): Mock<T>;
+        mockReturnThis(): Mock<T>;
+        mockReturnValue(value: any): Mock<T>;
+        mockReturnValueOnce(value: any): Mock<T>;
+    }
+
+    interface MockContext<T> {
+        calls: any[][];
+        instances: T[];
+    }
+}
+
+//Jest ships with a copy of Jasmine. They monkey-patch its APIs and divergence/deprecation are expected.
+//Relevant parts of Jasmine's API are below so they can be changed and removed over time.
+//This file can't reference jasmine.d.ts since the globals aren't compatible.
+
+declare function spyOn(object: any, method: string): jasmine.Spy;
+/** If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending. */
+declare function pending(reason?: string): void;
+/** Fails a test when called within one. */
+declare function fail(error?: any): void;
+declare namespace jasmine {
+    var clock: () => Clock;
+    function any(aclass: any): Any;
+    function anything(): Any;
+    function arrayContaining(sample: any[]): ArrayContaining;
+    function objectContaining(sample: any): ObjectContaining;
+    function createSpy(name: string, originalFn?: Function): Spy;
+    function createSpyObj(baseName: string, methodNames: any[]): any;
+    function createSpyObj<T>(baseName: string, methodNames: any[]): T;
+    function pp(value: any): string;
+    function addCustomEqualityTester(equalityTester: CustomEqualityTester): void;
+    function addMatchers(matchers: CustomMatcherFactories): void;
+    function stringMatching(value: string | RegExp): Any;
+
+    interface Clock {
+        install(): void;
+        uninstall(): void;
+        /** Calls to any registered callback are triggered when the clock is ticked forward via the jasmine.clock().tick function, which takes a number of milliseconds. */
+        tick(ms: number): void;
+        mockDate(date?: Date): void;
+    }
+
+    interface Any {
+        new (expectedClass: any): any;
+        jasmineMatches(other: any): boolean;
+        jasmineToString(): string;
+    }
+
+    interface ArrayContaining {
+        new (sample: any[]): any;
+        asymmetricMatch(other: any): boolean;
+        jasmineToString(): string;
+    }
+
+    interface ObjectContaining {
+        new (sample: any): any;
+        jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean;
+        jasmineToString(): string;
+    }
+
+    interface Spy {
+        (...params: any[]): any;
+        identity: string;
+        and: SpyAnd;
+        calls: Calls;
+        mostRecentCall: { args: any[]; };
+        argsForCall: any[];
+        wasCalled: boolean;
+    }
+
+    interface SpyAnd {
+        /** By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation. */
+        callThrough(): Spy;
+        /** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */
+        returnValue(val: any): Spy;
+        /** By chaining the spy with and.returnValues, all calls to the function will return specific values in order until it reaches the end of the return values list. */
+        returnValues(...values: any[]): Spy;
+        /** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */
+        callFake(fn: Function): Spy;
+        /** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */
+        throwError(msg: string): Spy;
+        /** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */
+        stub(): Spy;
+    }
+
+    interface Calls {
+        /** By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens. */
+        any(): boolean;
+        /** By chaining the spy with calls.count(), will return the number of times the spy was called */
+        count(): number;
+        /** By chaining the spy with calls.argsFor(), will return the arguments passed to call number index */
+        argsFor(index: number): any[];
+        /** By chaining the spy with calls.allArgs(), will return the arguments to all calls */
+        allArgs(): any[];
+        /** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls */
+        all(): CallInfo[];
+        /** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call */
+        mostRecent(): CallInfo;
+        /** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call */
+        first(): CallInfo;
+        /** By chaining the spy with calls.reset(), will clears all tracking for a spy */
+        reset(): void;
+    }
+
+    interface CallInfo {
+        /** The context (the this) for the call */
+        object: any;
+        /** All arguments passed to the call */
+        args: any[];
+        /** The return value of the call */
+        returnValue: any;
+    }
+
+    interface CustomMatcherFactories {
+        [index: string]: CustomMatcherFactory;
+    }
+
+    interface CustomMatcherFactory {
+        (util: MatchersUtil, customEqualityTesters: Array<CustomEqualityTester>): CustomMatcher;
+    }
+
+    interface MatchersUtil {
+        equals(a: any, b: any, customTesters?: Array<CustomEqualityTester>): boolean;
+        contains<T>(haystack: ArrayLike<T> | string, needle: any, customTesters?: Array<CustomEqualityTester>): boolean;
+        buildFailureMessage(matcherName: string, isNot: boolean, actual: any, ...expected: Array<any>): string;
+    }
+
+    interface CustomEqualityTester {
+        (first: any, second: any): boolean;
+    }
+
+    interface CustomMatcher {
+        compare<T>(actual: T, expected: T): CustomMatcherResult;
+        compare(actual: any, expected: any): CustomMatcherResult;
+    }
+
+    interface CustomMatcherResult {
+        pass: boolean;
+        message: string | (() => string);
+    }
+
+    interface ArrayLike<T> {
+        length: number;
+        [n: number]: T;
+    }
+}
diff --git a/jest/v16/jest-tests.ts b/jest/v16/jest-tests.ts
new file mode 100644
index 0000000000..c69eae61a2
--- /dev/null
+++ b/jest/v16/jest-tests.ts
@@ -0,0 +1,369 @@
+/// <reference types="node" />
+
+// Tests based on the Jest website
+jest.unmock('../sum');
+
+describe('sum', function() {
+    it('adds 1 + 2 to equal 3', function() {
+        var sum: (a: number, b: number) => number = require('../sum');
+        expect(sum(1, 2)).toBe(3);
+    });
+});
+
+describe('fetchCurrentUser', function() {
+    it('calls the callback when $.ajax requests are finished', function() {
+        var $ = require('jquery');
+        var fetchCurrentUser = require('../fetchCurrentUser');
+
+        // Create a mock function for our callback
+        var callback = jest.fn();
+        fetchCurrentUser(callback);
+
+        // Now we emulate the process by which `$.ajax` would execute its own
+        // callback
+        $.ajax.mock.calls[0 /*first call*/][0 /*first argument*/].success({
+            firstName: 'Bobby',
+            lastName: '");DROP TABLE Users;--'
+        });
+
+        // And finally we assert that this emulated call by `$.ajax` incurred a
+        // call back into the mock function we provided as a callback
+        expect(callback.mock.calls[0/*first call*/][0/*first arg*/]).toEqual({
+            loggedIn: true,
+            fullName: 'Bobby ");DROP TABLE Users;--'
+        });
+    });
+});
+
+// unmock is the recommended approach for unmocking...
+jest.unmock('../displayUser.js')
+
+describe('displayUser', function() {
+    it('displays a user after a click', function() {
+        // Set up our document body
+        document.body.innerHTML =
+            '<div>' +
+            '  <span id="username" />' +
+            '  <button id="button" />' +
+            '</div>';
+
+        var displayUser = require.requireActual('../displayUser');
+        var $ = require('jquery');
+        var fetchCurrentUser = require('../fetchCurrentUser');
+
+        // Tell the fetchCurrentUser mock function to automatically invoke
+        // its callback with some data
+        fetchCurrentUser.mockImplementation(function(cb: Function) {
+            cb({
+                loggedIn: true,
+                fullName: 'Johnny Cash'
+            });
+        });
+
+        // Use jquery to emulate a click on our button
+        $('#button').click();
+
+        // Assert that the fetchCurrentUser function was called, and that the
+        // #username span's innter text was updated as we'd it expect.
+        expect(fetchCurrentUser).toBeCalled();
+        expect($('#username').text()).toEqual('Johnny Cash - Logged In');
+    });
+});
+
+jest.unmock('../CheckboxWithLabel.js');
+describe('CheckboxWithLabel', function() {
+    it('changes the text after click', function() {
+        var React = require('react/addons');
+        var CheckboxWithLabel = require('../CheckboxWithLabel.js');
+        var TestUtils = React.addons.TestUtils;
+
+        // Render a checkbox with label in the document
+        var checkbox = TestUtils.renderIntoDocument(
+            CheckboxWithLabel({
+                    labelOn: "On",
+                    labelOff: "Off"
+                })
+        );
+
+        // Verify that it's Off by default
+        var label = TestUtils.findRenderedDOMComponentWithTag(
+            checkbox, 'label');
+        expect(label.getDOMNode().textContent).toEqual('Off');
+
+        // Simulate a click and verify that it is now On
+        var input = TestUtils.findRenderedDOMComponentWithTag(
+            checkbox, 'input');
+        TestUtils.Simulate.change(input);
+        expect(label.getDOMNode().textContent).toEqual('On');
+    });
+});
+
+jest.runAllTicks();
+xdescribe('Hooks and Suits', function () {
+    let tested: boolean;
+
+    beforeEach(function () {
+        tested = false;
+    });
+
+    afterEach(function () {
+       tested = true;
+    });
+
+    test('tested', function () {
+       expect(tested).toBeTruthy();
+       expect(tested).not.toBeFalsy();
+    });
+
+    fit('tested', function () {
+       expect(tested).toBeDefined();
+       expect(tested).not.toBeUndefined();
+    });
+
+    xit('expect null to be null', function () {
+       expect(null).toBeNull();
+    });
+});
+
+describe('compartion', function () {
+    var sum: (a: number, b: number) => number = require.requireMock('../sum');
+
+    it('compares is 7 + 2 greater than 3', function () {
+       expect(sum(7, 2)).toBeGreaterThan(3);
+    });
+
+    it('compares is 2 + 7 greater than or equal to 3', function () {
+       expect(sum(2, 7)).toBeGreaterThanOrEqual(3);
+    });
+
+    it('compares is 3 less than 3 + 4', function () {
+       expect(3).toBeLessThan(sum(3, 4));
+    });
+
+    it('compares is 3 less than or equal to 4 + 3', function () {
+       expect(3).toBeLessThanOrEqual(sum(4, 3));
+    });
+
+    it('works sanely with simple decimals', function () {
+        expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
+    });
+});
+
+describe('toThrow API', function () {
+   function throwTypeError(): void {
+       throw new TypeError('toThrow Definition was out of date');
+   }
+
+   it('throws', function () {
+      expect(throwTypeError()).toThrow();
+   });
+
+   it('throws TypeError', function () {
+       expect(throwTypeError()).toThrowError(TypeError);
+   });
+
+   it('throws \'Definition was out of date\'', function () {
+      expect(throwTypeError()).toThrowError(/Definition was out of date/);
+   });
+
+   it('throws \'toThorow Definition was out of date\'', function () {
+      expect(throwTypeError()).toThrowError('toThrow Definition was out of date');
+   });
+});
+
+describe('missing tests', function () {
+    it('creates closures', function () {
+       class Closure<T> {
+           private arg: T;
+
+           public constructor(private fn: (arg: T) => void) {
+               this.fn = fn;
+           }
+
+           public bind(arg: T): void {
+               this.arg = arg;
+           }
+
+           public call(): void {
+               this.fn(this.arg);
+           }
+       }
+
+       type StringClosure = (arg: string) => void;
+       let spy: jest.Mock<StringClosure> = jest.fn<StringClosure>();
+       let closure: Closure<string> = new Closure<string>(spy);
+       closure.bind('jest');
+       closure.call();
+       expect(spy).lastCalledWith('jest');
+       expect(spy).toBeCalledWith('jest');
+       expect(jest.isMockFunction(spy)).toBeTruthy();
+   });
+
+   it('tests all mising Mocks functionality', function () {
+       type FruitsGetter = () => Array<string>;
+       let mock: jest.Mock<FruitsGetter> = jest.fn<FruitsGetter>();
+       mock.mockImplementationOnce(() => ['Orange', 'Apple', 'Plum'])
+       jest.setMock('./../tesks/getFruits', mock);
+       const getFruits: FruitsGetter = require('./../tesks/getFruits');
+       expect(getFruits()).toContain('Orange');
+       mock.mockReturnValueOnce(['Apple', 'Plum']);
+       expect(mock()).not.toContain('Orange');
+       const myBeverage: any = {delicious: true, sour: false};
+       expect(myBeverage).toContainEqual({delicious: true, sour: false});
+       mock.mockReturnValue([]); //Deprecated: Use jest.fn(() => value) instead.
+       mock.mockClear();
+       let thisMock: jest.Mock<any> = jest.fn<any>().mockReturnThis();
+       expect(thisMock()).toBe(this);
+   });
+
+   it('creates snapshoter', function () {
+       jest.disableAutomock().mock('./render', () => jest.fn((): string => "{Link to: \"facebook\"}"), { virtual: true });
+       const render: () => string = require('./render');
+       expect(render()).toMatch(/Link/);
+       jest.enableAutomock();
+   });
+
+   it('runs only pending timers', function () {
+        jest.useRealTimers();
+        setTimeout(() => expect(1).not.toEqual(0), 3000);
+        jest.runOnlyPendingTimers().runTimersToTime(300);
+   });
+
+   it('runs all timers', function () {
+        jest.clearAllTimers();
+        jest.useFakeTimers();
+        setTimeout(() => expect(0).not.toEqual(1), 3000);
+        jest.runAllTimers();
+   });
+
+   it('cleares cache', function () {
+       const sum1 = require('../sum');
+       jest.resetModules();
+       const sum2 = require('../sum');
+       expect(sum1).not.toBe(sum2);
+   })
+});
+
+describe('toMatchSnapshot', function () {
+   it('compares snapshots', function () {
+        expect({ type: 'a', props: { href: 'https://www.facebook.com/' }, children: [ 'Facebook' ] }).toMatchSnapshot();
+    });
+});
+
+describe('toThrowErrorMatchingSnapshot', function () {
+   it('compares snapshots', function () {
+        expect(() => { throw new Error('descriptiton') }).toThrowErrorMatchingSnapshot();
+    });
+});
+
+function testInstances() {
+    var mockFn = jest.fn<Function>();
+    var a = new mockFn();
+    var b = new mockFn();
+
+    mockFn.mock.instances[0] === a; // true
+    mockFn.mock.instances[1] === b; // true
+}
+
+function testMockImplementation() {
+    var mockFn = jest.fn<Function>().mockImplementation(function (scalar:number):number {
+        return 42 + scalar;
+    });
+
+    var a = mockFn(0);
+    var b = mockFn(1);
+
+    a === 42; // true
+    b === 43; // true
+
+    mockFn.mock.calls[0][0] === 0; // true
+    mockFn.mock.calls[1][0] === 1; // true
+}
+
+// Test from jest Docs: <http://facebook.github.io/jest/docs/manual-mocks.html#content>
+describe('genMockFromModule', function () {
+   // Interfaces:
+    interface MockFiles {
+        [index: string]: string;
+    }
+
+    interface MockedFS {
+        readdirSync: (dir: string) => string[];
+        __setMockFiles: (newMockFiles: MockFiles) => void ;
+    }
+
+    // ------------------------------------------------------------------------------------
+    // FileSummarizer.ts
+
+    const fs = require('fs');
+
+    function summarizeFilesInDirectorySync(directory: string): string[] {
+      return fs.readdirSync(directory).map((fileName: string) => ({
+        fileName,
+        directory,
+      }));
+    }
+
+    //export default summarizeFilesInDirectorySync; // For sake of compilation
+
+    // ------------------------------------------------------------------------------------
+    // __mocks__/fs.js
+
+    const path = require('path');
+
+    const mockedFS: MockedFS = jest.genMockFromModule<MockedFS>('fs');
+
+    let mockFiles: any = Object.create(null);
+    function __setMockFiles(newMockFiles: MockFiles): void {
+      mockFiles = Object.create(null);
+      for(const file in newMockFiles) {
+        const dir: string = path.dirname(file);
+
+        if (!mockFiles[dir]) {
+          mockFiles[dir] = [];
+        }
+        mockFiles[dir].push(path.basename(file));
+      }
+    }
+
+    function readdirSync(directoryPath: string): string[] {
+      return mockFiles[directoryPath] || [];
+    }
+
+    mockedFS.readdirSync = readdirSync;
+    mockedFS.__setMockFiles = __setMockFiles;
+
+    //export = mockedFS; // For sake of compilation
+    // ------------------------------------------------------------------------------------
+    // __tests__/FileSummarizer-test.js
+
+    jest.mock('fs');
+
+    describe('listFilesInDirectorySync', () => {
+      const MOCK_FILE_INFO: MockFiles = {
+        '/path/to/file1.js': 'console.log("file1 contents");',
+        '/path/to/file2.txt': 'file2 contents',
+      };
+
+      beforeEach(() => {
+        // Set up some mocked out file info before each test
+        (require('fs') as MockedFS).__setMockFiles(MOCK_FILE_INFO);
+      });
+
+      it('includes all files in the directory in the summary', () => {
+        const FileSummarizer: (dir: string) => string[] = require('../FileSummarizer');
+        const fileSummary = FileSummarizer('/path/to');
+
+        expect(fileSummary.length).toBe(2);
+      });
+    });
+});
+
+/**
+ * Pass strictNullChecks
+ */
+describe('strictNullChecks', function () {
+    it('does not complain when using done callback', (done) => {
+        done();
+    })
+});
diff --git a/jest/v16/tsconfig.json b/jest/v16/tsconfig.json
new file mode 100644
index 0000000000..1bf1d9e78b
--- /dev/null
+++ b/jest/v16/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": false,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "jest-tests.ts"
+    ]
+}

From bb0a14e75e57420932e421d4cb0c3a151fc934e6 Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Thu, 26 Jan 2017 18:17:44 +0100
Subject: [PATCH 45/87] Removed redunant intersection

---
 jest/index.d.ts    | 10 ++++++----
 jest/jest-tests.ts |  4 ++++
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index acfe70a0f6..6e204db890 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -32,7 +32,9 @@ declare namespace jest {
     function autoMockOff(): typeof jest;
     /** Enables automatic mocking in the module loader. */
     function autoMockOn(): typeof jest;
-    /** @deprecated */
+    /**
+     * @deprecated use resetAllMocks instead
+     */
     function clearAllMocks(): typeof jest;
     /** Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function. */
     function resetAllMocks(): typeof jest;
@@ -124,7 +126,7 @@ declare namespace jest {
             ensureExpectedIsNumber(actual: any, matcherName?: string): void;
             ensureNoExpected(actual: any, matcherName?: string): void;
             ensureNumbers(actual: any, expected: any, matcherName?: string): void;
-            /** get the type of a value with handling the edge cases like `typeof []` and `typeof null` */
+            /** get the type of a value with handling of edge cases like `typeof []` and `typeof null` */
             getType(value: any): string;
             matcherHint(matcherName: string, received?: string, expected?: string, options?: { secondArgument?: string, isDirectExpectCall?: boolean }): string;
             pluralize(word: string, count: number): string;
@@ -142,7 +144,7 @@ declare namespace jest {
     interface Expect {
         (actual: any): Matchers;
         anything(): void;
-        any(cs: any): void;
+        any(classType: any): void;
         arrayContaining(arr: any[]): void;
         assertions(num: number): void;
         extend(obj: ExpectExtendMap): void;
@@ -202,7 +204,7 @@ declare namespace jest {
      *  const myApi: jest.Mocked<Api> = new Api() as any;
      *  myApi.myApiMethod.mockImplementation(() => "test");
      */
-    type Mocked<T> = T & {
+    type Mocked<T> = {
         [P in keyof T]: T[P] & MockInstance<T>;
     };
 
diff --git a/jest/jest-tests.ts b/jest/jest-tests.ts
index d2fcd6d007..0cc6089ca8 100644
--- a/jest/jest-tests.ts
+++ b/jest/jest-tests.ts
@@ -434,12 +434,16 @@ class TestApi {
 
 declare function mockedFunc(a: number): string;
 
+declare function mockedFuncWithApi(api: TestApi): void;
+
 describe('Mocked type', function () {
     it('Works', function () {
         const mock: jest.Mocked<TestApi> = new TestApi() as any;
         mock.testProp;
         mock.testMethod.mockImplementation(() => 'test');
         mock.testMethod(5).toUpperCase();
+
+        mockedFuncWithApi(mock);
     });
 });
 

From 1ed54727eb8e2fc93b6719930e5c62b32b938040 Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Thu, 26 Jan 2017 18:45:28 +0100
Subject: [PATCH 46/87] Fix tsconfig for jest v16

---
 jest/v16/tsconfig.json | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/jest/v16/tsconfig.json b/jest/v16/tsconfig.json
index 1bf1d9e78b..9d7a7f6921 100644
--- a/jest/v16/tsconfig.json
+++ b/jest/v16/tsconfig.json
@@ -8,10 +8,14 @@
         "noImplicitAny": true,
         "noImplicitThis": false,
         "strictNullChecks": true,
-        "baseUrl": "../",
+        "baseUrl": "../../",
         "typeRoots": [
-            "../"
+            "../../"
         ],
+        "paths": {
+          "jest": ["jest/v16"],
+          "jest/*": ["jest/v16"]
+        },
         "types": [],
         "noEmit": true,
         "forceConsistentCasingInFileNames": true

From 2ad8a85892d92943d6262bc59ec667fc16bd5d8d Mon Sep 17 00:00:00 2001
From: Alexey Svetliakov <asvetliakov@teledini.com>
Date: Thu, 26 Jan 2017 18:46:02 +0100
Subject: [PATCH 47/87] Wildcard in path

---
 jest/v16/tsconfig.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/jest/v16/tsconfig.json b/jest/v16/tsconfig.json
index 9d7a7f6921..2e023e1205 100644
--- a/jest/v16/tsconfig.json
+++ b/jest/v16/tsconfig.json
@@ -14,7 +14,7 @@
         ],
         "paths": {
           "jest": ["jest/v16"],
-          "jest/*": ["jest/v16"]
+          "jest/*": ["jest/v16/*"]
         },
         "types": [],
         "noEmit": true,

From 576836745347dc13351fdb0233c956b273e1aec0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B8rgen=20Elgaard=20Larsen?= <jel@elgaard.net>
Date: Thu, 26 Jan 2017 19:01:52 +0100
Subject: [PATCH 48/87] html-to-text: wordwrap option can be false/null

According to documentation, the "wordwrap" option can be either a number, false, or null.
---
 html-to-text/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/html-to-text/index.d.ts b/html-to-text/index.d.ts
index ce02e4bfe5..406908a6ce 100644
--- a/html-to-text/index.d.ts
+++ b/html-to-text/index.d.ts
@@ -39,7 +39,7 @@ interface HtmlToTextOptions {
      * Defines after how many chars a line break should follow in p elements.
      * Set to null or false to disable word-wrapping. Default: 80
      */
-    wordwrap?: number;
+    wordwrap?: number | false | null;
 
     /**
      *  Allows to select certain tables by the class or id attribute from the HTML

From 66d3bd4a3cf9a31165485ea590d94aa0971facac Mon Sep 17 00:00:00 2001
From: Jacob Baskin <jacob@sidewalklabs.com>
Date: Thu, 26 Jan 2017 14:32:36 -0500
Subject: [PATCH 49/87] Add typings for moment-round

---
 moment-round/index.d.ts            | 14 ++++++++++++++
 moment-round/moment-round-tests.ts |  8 ++++++++
 moment-round/tsconfig.json         | 20 ++++++++++++++++++++
 moment-round/tslint.json           |  1 +
 4 files changed, 43 insertions(+)
 create mode 100644 moment-round/index.d.ts
 create mode 100644 moment-round/moment-round-tests.ts
 create mode 100644 moment-round/tsconfig.json
 create mode 100644 moment-round/tslint.json

diff --git a/moment-round/index.d.ts b/moment-round/index.d.ts
new file mode 100644
index 0000000000..e68181ac34
--- /dev/null
+++ b/moment-round/index.d.ts
@@ -0,0 +1,14 @@
+// Type definitions for moment-round 1.0
+// Project: https://github.com/WebDevTmas/moment-round
+// Definitions by: Jacob Baskin <https://github.com/jacobbaskin>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import * as moment from 'moment';
+
+declare module 'moment' {
+    interface Moment {
+        round(precision: number, key: string, direction: 'round' | 'ceil' | 'floor'): Moment;
+        ceil(precision: number, key: string): Moment;
+        floor(precision: number, key: string): Moment;
+    }
+}
diff --git a/moment-round/moment-round-tests.ts b/moment-round/moment-round-tests.ts
new file mode 100644
index 0000000000..6925966365
--- /dev/null
+++ b/moment-round/moment-round-tests.ts
@@ -0,0 +1,8 @@
+import * as moment from 'moment';
+
+var m = new moment(); // 2015-06-18 15:30:19
+moment.round(5, 'seconds'); // 2015-06-18 15:30:20
+moment.ceil(3, 'minutes'); // 2015-06-18 15:33:00
+moment.floor(16, 'hours'); // 2015-06-18 00:00:00
+moment.ceil(21, 'hours'); // 2015-06-18 21:00:00
+moment.ceil(20, 'hours'); // 2015-06-19 00:00:00
diff --git a/moment-round/tsconfig.json b/moment-round/tsconfig.json
new file mode 100644
index 0000000000..7054df992f
--- /dev/null
+++ b/moment-round/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "moment-round-tests.ts"
+    ]
+}
diff --git a/moment-round/tslint.json b/moment-round/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/moment-round/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From f4a5b2bfb5d35876d87b9484762926f9e8c571a5 Mon Sep 17 00:00:00 2001
From: Jacob Baskin <jacob@sidewalklabs.com>
Date: Thu, 26 Jan 2017 14:36:39 -0500
Subject: [PATCH 50/87] Add 'export = moment'

---
 moment-round/index.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/moment-round/index.d.ts b/moment-round/index.d.ts
index e68181ac34..8e6ac65cf5 100644
--- a/moment-round/index.d.ts
+++ b/moment-round/index.d.ts
@@ -5,6 +5,8 @@
 
 import * as moment from 'moment';
 
+export = moment;
+
 declare module 'moment' {
     interface Moment {
         round(precision: number, key: string, direction: 'round' | 'ceil' | 'floor'): Moment;

From fab0c1b8dd929e38bc58f569149a34b153eec477 Mon Sep 17 00:00:00 2001
From: Jacob Baskin <jacob@sidewalklabs.com>
Date: Thu, 26 Jan 2017 14:43:58 -0500
Subject: [PATCH 51/87] Fix moment-round typings

---
 moment-round/index.d.ts            |  2 +-
 moment-round/moment-round-tests.ts | 12 ++++++------
 moment-round/package.json          |  5 +++++
 3 files changed, 12 insertions(+), 7 deletions(-)
 create mode 100644 moment-round/package.json

diff --git a/moment-round/index.d.ts b/moment-round/index.d.ts
index 8e6ac65cf5..441cec3f6f 100644
--- a/moment-round/index.d.ts
+++ b/moment-round/index.d.ts
@@ -9,7 +9,7 @@ export = moment;
 
 declare module 'moment' {
     interface Moment {
-        round(precision: number, key: string, direction: 'round' | 'ceil' | 'floor'): Moment;
+        round(precision: number, key: string, direction?: 'round' | 'ceil' | 'floor'): Moment;
         ceil(precision: number, key: string): Moment;
         floor(precision: number, key: string): Moment;
     }
diff --git a/moment-round/moment-round-tests.ts b/moment-round/moment-round-tests.ts
index 6925966365..063e3cbea4 100644
--- a/moment-round/moment-round-tests.ts
+++ b/moment-round/moment-round-tests.ts
@@ -1,8 +1,8 @@
 import * as moment from 'moment';
 
-var m = new moment(); // 2015-06-18 15:30:19
-moment.round(5, 'seconds'); // 2015-06-18 15:30:20
-moment.ceil(3, 'minutes'); // 2015-06-18 15:33:00
-moment.floor(16, 'hours'); // 2015-06-18 00:00:00
-moment.ceil(21, 'hours'); // 2015-06-18 21:00:00
-moment.ceil(20, 'hours'); // 2015-06-19 00:00:00
+var m = moment();
+m.round(5, 'seconds');
+m.ceil(3, 'minutes');
+m.floor(16, 'hours');
+m.ceil(21, 'hours');
+m.ceil(20, 'hours');
diff --git a/moment-round/package.json b/moment-round/package.json
new file mode 100644
index 0000000000..4c6d24a445
--- /dev/null
+++ b/moment-round/package.json
@@ -0,0 +1,5 @@
+{
+    "dependencies": {
+        "moment": ">=2.14.0"
+    }
+}
\ No newline at end of file

From c305081cf1e3d850559e146763f2cd34b4e0a080 Mon Sep 17 00:00:00 2001
From: Ben Herila <ben+gh@herila.net>
Date: Thu, 26 Jan 2017 14:00:30 -0800
Subject: [PATCH 52/87] Update credit-card-type to support latest prefixPattern
 and exactPattern

---
 credit-card-type/index.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/credit-card-type/index.d.ts b/credit-card-type/index.d.ts
index 59886b5e60..8625e5e5f8 100644
--- a/credit-card-type/index.d.ts
+++ b/credit-card-type/index.d.ts
@@ -10,7 +10,8 @@ declare namespace creditCardType {
     interface CreditCardTypeInfo {
         niceType?: string
         type?: CardBrand
-        pattern?: RegExp
+        prefixPattern?: RegExp
+        exactPattern?: RegExp
         gaps?: Array<number>
         lengths?: Array<number>
         code?: {

From 81730dfd225b778bfd0f0a7e1524899a372ad37c Mon Sep 17 00:00:00 2001
From: Kanchalai Tanglertsampan <yuisu@microsoft.com>
Date: Thu, 26 Jan 2017 16:36:27 -0800
Subject: [PATCH 53/87] Fix #11566 allows SFC to return null

---
 react/index.d.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/react/index.d.ts b/react/index.d.ts
index 8bf7bb21af..6f88127305 100644
--- a/react/index.d.ts
+++ b/react/index.d.ts
@@ -201,7 +201,7 @@ declare namespace React {
 
     type SFC<P> = StatelessComponent<P>;
     interface StatelessComponent<P> {
-        (props: P & { children?: ReactNode }, context?: any): ReactElement<any>;
+        (props: P & { children?: ReactNode }, context?: any): ReactElement<any> | null;
         propTypes?: ValidationMap<P>;
         contextTypes?: ValidationMap<any>;
         defaultProps?: P;
@@ -2620,7 +2620,9 @@ declare namespace React {
 
 declare global {
     namespace JSX {
-        interface Element extends React.ReactElement<any> { }
+        interface JSXElement extends React.ReactElement<any> { }
+        type Element = JSXElement | null;
+
         interface ElementClass extends React.Component<any, any> {
             render(): JSX.Element | null;
         }

From 2a505f885e5dbe105a847e52733692aab7934e90 Mon Sep 17 00:00:00 2001
From: Stephen Lautier <stephen.lautier@outlook.com>
Date: Fri, 27 Jan 2017 02:31:43 +0100
Subject: [PATCH 54/87] Added definitions for node-waves

---
 node-waves/index.d.ts          | 67 ++++++++++++++++++++++++++++++++++
 node-waves/node-waves-tests.ts | 10 +++++
 node-waves/tsconfig.json       | 20 ++++++++++
 node-waves/tslint.json         |  1 +
 4 files changed, 98 insertions(+)
 create mode 100644 node-waves/index.d.ts
 create mode 100644 node-waves/node-waves-tests.ts
 create mode 100644 node-waves/tsconfig.json
 create mode 100644 node-waves/tslint.json

diff --git a/node-waves/index.d.ts b/node-waves/index.d.ts
new file mode 100644
index 0000000000..2dc1f8f129
--- /dev/null
+++ b/node-waves/index.d.ts
@@ -0,0 +1,67 @@
+// Type definitions for node-waves 0.7
+// Project: http://fian.my.id/Waves
+// Definitions by: Stephen Lautier <https://github.com/stephenlautier>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+type ElementTarget = string | Element | Element[];
+
+export interface WavesConfig {
+	/**
+	 * Determines how long the waves effect duration (in milliseconds).
+	 *
+	 */
+	duration?: number;
+
+	/**
+	 * Delay amount to show waves effect on touch and hide the effect if user scrolls.
+	 * Set to 0 to disable delay (in milliseconds).
+	 *
+	 */
+	delay?: number;
+}
+
+export interface RippleOptions {
+
+	/**
+	 * Specify how long to wait between starting and stopping the ripple.
+	 *
+	 */
+	wait?: number | null;
+
+	/**
+	 * Specify the position inside the element.
+	 *
+	 */
+	position?: {
+		x: number;
+		y: number;
+	} | null
+}
+
+/**
+ * Initializes waves with an optional config.
+ */
+export function init(config?: WavesConfig): void;
+
+/**
+ * Attach ripple effect by adding `.waves-effect` to HTML element.
+ * Make sure you call `init` to activate the ripple.
+ *
+ * @param {ElementTarget} elements elements to target.
+ * @param {(string | string[])} [classes] classes to add.
+ */
+export function attach(elements: ElementTarget, classes?: string | string[]): void;
+
+/**
+ * Creates a ripple effect in HTML element programmatically.
+ * @param {ElementTarget} elements elements to target (must have `.waves-effect` already applied, ideally via `attach`).
+ * @param {RippleOptions} [options] specify how long to wait between starting and stopping the ripple, and it's position inside the element.
+ */
+export function ripple(elements: ElementTarget, options?: RippleOptions): void;
+
+/**
+ * Removes all ripples from inside an element immediately.
+ *
+ * @param {ElementTarget} elements elements to remove ripples from.
+ */
+export function calm(elements: ElementTarget): void;
diff --git a/node-waves/node-waves-tests.ts b/node-waves/node-waves-tests.ts
new file mode 100644
index 0000000000..adfb59703a
--- /dev/null
+++ b/node-waves/node-waves-tests.ts
@@ -0,0 +1,10 @@
+
+import { init, ripple, attach, calm } from "node-waves";
+
+init({ delay: 300 });
+
+attach("button", "waves-light");
+
+ripple(".box", { wait: null });
+
+calm(".box");
diff --git a/node-waves/tsconfig.json b/node-waves/tsconfig.json
new file mode 100644
index 0000000000..c069824144
--- /dev/null
+++ b/node-waves/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "node-waves-tests.ts"
+    ]
+}
diff --git a/node-waves/tslint.json b/node-waves/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/node-waves/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From ac7c3dd3a1edabe9eceb98c4bc07a4562ac9b2fd Mon Sep 17 00:00:00 2001
From: Stephen Lautier <stephen.lautier@outlook.com>
Date: Fri, 27 Jan 2017 02:34:37 +0100
Subject: [PATCH 55/87] fix lint issue

---
 node-waves/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/node-waves/index.d.ts b/node-waves/index.d.ts
index 2dc1f8f129..ce5c63da2e 100644
--- a/node-waves/index.d.ts
+++ b/node-waves/index.d.ts
@@ -35,7 +35,7 @@ export interface RippleOptions {
 	position?: {
 		x: number;
 		y: number;
-	} | null
+	} | null;
 }
 
 /**

From 42851a78ec22ffffc1c326178fb8880acf400472 Mon Sep 17 00:00:00 2001
From: Shun <shuntksh@gmail.com>
Date: Thu, 26 Jan 2017 20:13:31 -0800
Subject: [PATCH 56/87] Change typing structure to namespace basis

---
 forever-monitor/index.d.ts | 184 ++++++++++++++++++-------------------
 1 file changed, 88 insertions(+), 96 deletions(-)

diff --git a/forever-monitor/index.d.ts b/forever-monitor/index.d.ts
index 58c32ec5e6..d59c446f1a 100644
--- a/forever-monitor/index.d.ts
+++ b/forever-monitor/index.d.ts
@@ -4,101 +4,93 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 /// <reference types="node" />
 
-interface spawnWith {
-    customFds: number[];
-    setsid: boolean;
-    uid: number;
-    gid: number;
+declare namespace forever {
+    export interface SpawnWith {
+        customFds: number[];
+        setsid: boolean;
+        uid: number;
+        gid: number;
+    }
+
+    export interface Options {
+        silent?: boolean;
+        uid?: string;
+        pidFile?: string;
+        max?: number;
+        killTree?: boolean;
+        minUptime?: number;
+        spinSleepTime?: number;
+        command?: string;
+        args?: string[];
+        sourceDir?: string;
+        watch?: boolean;
+        watchIgnoreDotFiles?: boolean;
+        watchIgnorePatters?: string[];
+        watchDirectory?: string;
+        spawnWith?: SpawnWith;
+        env?: { [envKey: string]: string; };
+        cwd?: string;
+        logFile?: string;
+        outFile?: string;
+        errFile?: string;
+        parser?: (command: string, args: string[]) => { command: string, args: string[] };
+    }
+
+    export function start(script: string, options: Options): Monitor;
+    export function kill(pid: number, killTree?: boolean, signal?: string, callback?: () => any): void;
+    export function checkProcess(pid: number): boolean;
+    export const version: string;
+    export class Monitor extends NodeJS.EventEmitter {
+
+        /**
+         * @param script - Location of the target script to run.
+         * @param [options] - Configuration for this instance.
+         */
+        constructor(script: string, options?: Options);
+
+        /**
+         * @description Start the process that this instance is configured for
+         * @param [restart] - Value indicating whether this is a restart.
+         */
+        start(restart?: boolean): this;
+
+        /**
+         * @description Tries to spawn the target Forever child process.
+         */
+        trySpawn(): boolean;
+
+        /**
+         * @description Restarts the target script associated with this instance.
+         */
+        restart(): this;
+
+        /**
+         * @description Stops the target script associated with this instance. Prevents it from auto-respawning
+         */
+        stop(): this;
+
+        /**
+         * @description Kills the ChildProcess object associated with this instance
+         * @param [forceStop] - Value indicating whether short circuit forever auto-restart
+         */
+        kill(forceStop?: boolean): this;
+
+        /**
+         * @description Sends a message to a forked ChildProcess object associated with this instance
+         */
+        send(msg?: any): this;
+
+        /**
+         * respond with JSON for this instance
+         */
+        toString(): string;
+
+        /**
+         * @param command - Command string to parse
+         * @param args - Additional default arguments
+         */
+        parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
+    }
 }
 
-interface parserArgs {
-    command: string;
-    args: string[];
-}
-
-interface Options {
-    silent?: boolean;
-    uid?: "autogen" | string;
-    pidFile?: string;
-    max?: number;
-    killTree?: boolean;
-    minUptime?: number;
-    spinSleepTime?: number;
-    command?: "node" | string;
-    args?: string[];
-    sourceDir?: string;
-    watch?: boolean;
-    watchIgnoreDotFiles?: boolean;
-    watchIgnorePatters?: string[];
-    watchDirectory?: string;
-    spawnWith?: spawnWith;
-    env?: { [envKey: string]: string; };
-    cwd?: string;
-    logFile?: string;
-    outFile?: string;
-    errFile?: string;
-    parser?: (command: string, args: string[]) => { command: string, args: string[] };
-}
-
-
-export declare class Monitor extends NodeJS.EventEmitter {
-
-    /**
-     * @param script - Location of the target script to run.
-     * @param [options] - Configuration for this instance.
-     */
-    constructor(script: string, options?: Options);
-
-    /**
-     * @description Start the process that this instance is configured for
-     * @param [restart] - Value indicating whether this is a restart.
-     */
-    start(restart?: boolean): this;
-
-    /**
-     * @description Tries to spawn the target Forever child process.
-     */
-    trySpawn(): boolean;
-
-    /**
-     * @description Restarts the target script associated with this instance.
-     */
-    restart(): this;
-
-    /**
-     * @description Stops the target script associated with this instance. Prevents it from auto-respawning
-     */
-    stop(): this;
-
-    /**
-     * @description Kills the ChildProcess object associated with this instance
-     * @param [forceStop] - Value indicating whether short circuit forever auto-restart
-     */
-    kill(forceStop?: boolean): this;
-
-    /**
-     * @description Sends a message to a forked ChildProcess object associated with this instance
-     */
-    send(msg?: any): this;
-
-    /**
-     * respond with JSON for this instance
-     */
-    toString(): string;
-
-    /**
-     * @param command - Command string to parse
-     * @param args - Additional default arguments
-     */
-    parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
-}
-
-interface forever {
-    Monitor: Monitor;
-    start: (script: string, options: Options) => Monitor;
-    kill: (pid: number, killTree?: boolean, signal?: string, callback?: () => any) => void;
-    checkProcess: (pid: number) => boolean;
-    version: string;
-}
-
-export default forever;
+export = forever;

From c4b29bb2d0b789804b802729621b94b5bd928e3c Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Fri, 27 Jan 2017 08:20:31 +0200
Subject: [PATCH 57/87] Pino - move interface inside the namespace

---
 pino/index.d.ts | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/pino/index.d.ts b/pino/index.d.ts
index 8d2b687f0b..6273d2fc65 100644
--- a/pino/index.d.ts
+++ b/pino/index.d.ts
@@ -10,24 +10,24 @@ import stream = require('stream');
 declare function P(optionsOrStream?: P.LoggerOptions | stream.Writable | stream.Duplex | stream.Transform): P.Logger;
 declare function P(options: P.LoggerOptions, stream: stream.Writable | stream.Duplex | stream.Transform): P.Logger;
 
-interface IPinoLog {
-    pid: number
-    hostname: string
-    level: number
-    time: string
-    msg: string
-    v: number
-}
-
 declare namespace P {
 
-    function pretty(opts?: {timeTransOnly?: boolean, levelFirst?: boolean, formatter?: (log: IPinoLog) => string}): stream.Transform;
+    function pretty(opts?: { timeTransOnly?: boolean, levelFirst?: boolean, formatter?: (log: IPinoLog) => string }): stream.Transform;
 
     type Level = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
     interface Headers {
         [header: string]: string;
     }
 
+    interface IPinoLog {
+        pid: number
+        hostname: string
+        level: number
+        time: string
+        msg: string
+        v: number
+    }
+
     interface LevelLabelsToValues {
         [level: string]: number;
     }

From ba6a418311d7ea62117f9c3317cdcfce8022e318 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Fri, 27 Jan 2017 08:49:48 +0200
Subject: [PATCH 58/87] Steed - declare namespace and modify tests

---
 steed/index.d.ts     |  79 +++++++++++++-------------
 steed/steed-tests.ts | 129 +++++++++++++++++--------------------------
 2 files changed, 92 insertions(+), 116 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index f88669e92c..ba4b199999 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,48 +3,49 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T; }
-interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void; }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+declare namespace steed {
+    interface Dictionary<T> { [key: string]: T; }
+    interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+    interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+    interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+    interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedQueue<T> {
-    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    pause(): void;
-    resume(): void;
-    idle(): boolean;
-    length(): number;
-    kill(): void;
-    concurrency: number;
-    drain: () => any;
-    empty: () => any;
-    saturated: () => any;
+    interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+    interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+    interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+    interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+
+    interface SteedQueue<T> {
+        push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+        unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+        pause(): void;
+        resume(): void;
+        idle(): boolean;
+        length(): number;
+        kill(): void;
+        concurrency: number;
+        drain: () => any;
+        empty: () => any;
+        saturated: () => any;
+    }
+
+    interface Steed {
+        parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+        each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+        eachSeries: typeof steed.each;
+        map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+        mapSeries: typeof steed.map;
+        queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+        queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
+    }
 }
 
-interface Steed {
-    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    mapSeries: typeof steed.map;
-    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
-}
+declare const steed: steed.Steed;
 
-declare const steed: Steed;
-
-declare module "steed" {
-    export = steed;
-}
+export = steed;
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 729e59472f..685654cc52 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -1,19 +1,14 @@
 /// <reference types="node" />
 
-import fs = require("fs");
-import process = require("process");
+import steed = require('steed')
 
 declare var path: {
-    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
+    exists: (path: string, callback?: (error: Error, exists: boolean) => any) => void;
 };
 
-function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
+function funcStringCbErrBoolean(v: string, cb: (error: Error, res: boolean) => void) { }
 function callback() { }
 
-steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-
-
 steed.parallel([
     function () { },
     function () { }
@@ -25,16 +20,16 @@ steed.series([
 ]);
 
 var data: any[] = [];
-function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
-steed.map(data, steedProcess, function (err, results) {
+function steedProcess(item: any, callback: (error: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (error, results) {
     console.log(results);
 });
 
 var openFiles = ['file1', 'file2'];
 
-var saveFile = function (file:string,cb:(err:Error)=>void) { }
-steed.each(openFiles, saveFile, function (err:Error) { });
-steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+var saveFile = function (file: string, cb: (error: Error) => void) { }
+steed.each(openFiles, saveFile, function (error: Error) { });
+steed.eachSeries(openFiles, saveFile, function (error: Error) { });
 
 // Control Flow //
 
@@ -46,9 +41,9 @@ steed.series([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<string,Error>([
+steed.series<string, Error>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -56,7 +51,7 @@ steed.series<string,Error>([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 steed.series({
     one: function (callback) {
@@ -70,9 +65,9 @@ steed.series({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<number,Error>({
+steed.series<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -84,7 +79,7 @@ steed.series<number,Error>({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
 steed.parallel([
     function (callback) {
@@ -98,9 +93,9 @@ steed.parallel([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<string,Error>([
+steed.parallel<string, Error>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -112,7 +107,7 @@ steed.parallel<string,Error>([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 
 steed.parallel({
@@ -127,9 +122,9 @@ steed.parallel({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<number,Error>({
+steed.parallel<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -141,7 +136,7 @@ steed.parallel<number,Error>({
         }, 100);
     },
 },
-    function (err, results) { });
+    function (error, results) { });
 
 function whileFn(callback: any) {
     count++;
@@ -161,10 +156,10 @@ steed.waterfall([
     function (arg1: any, callback: any) {
         callback(null, 'done');
     }
-], function (err, result) { });
+], function (error, result) { });
 
 
-var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+var q = steed.queue<any, Error>(function (task: any, callback: () => void) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -180,7 +175,7 @@ q.push({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
@@ -190,22 +185,22 @@ q.unshift({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
-var qLength : number = q.length();
-var qIsIdle : boolean = q.idle();
+var qLength: number = q.length();
+var qIsIdle: boolean = q.idle();
 
-q.saturated = function() {
+q.saturated = function () {
     console.log('queue is saturated.');
 }
 
-q.empty = function() {
+q.empty = function () {
     console.log('queue is empty.');
 }
 
-q.drain = function() {
+q.drain = function () {
     console.log('queue was drained.');
 }
 
@@ -214,7 +209,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = steed.queue<string, Error>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -225,7 +220,7 @@ q2.push('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.push(['task3', 'task4', 'task5'], function (error) {
+q2.push(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
@@ -235,49 +230,29 @@ q2.unshift('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.unshift(['task3', 'task4', 'task5'], function (error) {
+q2.unshift(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
-
-// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-//     console.log('hello ' + level);
-//     callback(null, level+1);
-// });
-//
-// aq.push(1, function (err : Error, newLevel : number) {
-//     console.log('finished processing bar' + newLevel);
-// });
-
-
 steed.parallel([
-    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback: (error: Error, val: string) => void) { },
     function (callback) { }
 ],
-function (err:Error,results:Array<string>) {
-    steed.series([
-        function (callback) { },
-        function email_link(callback) { }
-    ]);
-});
-
-steed.parallel([
-    function (callback) {
-        fs.writeFile('testfile1', 'test1', callback);
-    },
-    function (callback) {
-        fs.writeFile('testfile2', 'test2', callback);
-    },
-]);
+    function (error: Error, results: Array<string>) {
+        steed.series([
+            function (callback) { },
+            function email_link(callback) { }
+        ]);
+    });
 
 // each
 
-steed.each<number,Error>({
+steed.each<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.each: ${val}`);
 
@@ -285,7 +260,7 @@ steed.each<number,Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.each: done.");
 
@@ -294,9 +269,9 @@ steed.each<number,Error>({
 steed.eachSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.eachSeries: ${val}`);
 
@@ -304,7 +279,7 @@ steed.eachSeries<number, Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.eachSeries: done.");
 
@@ -316,9 +291,9 @@ steed.map<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.map: ${val}`);
 
@@ -326,7 +301,7 @@ steed.map<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.map: done with results", results);
 
@@ -336,9 +311,9 @@ steed.mapSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.mapSeries: ${val}`);
 
@@ -346,7 +321,7 @@ steed.mapSeries<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.mapSeries: done with results", results);
 

From 0bbcfcfffca381dd8c02d7f932f7f8bdbf600752 Mon Sep 17 00:00:00 2001
From: Sheeo <sheeo@sheeo.dk>
Date: Fri, 27 Jan 2017 08:48:50 +0100
Subject: [PATCH 59/87] Add _.conforms and _.conformsTo

---
 lodash/index.d.ts      | 32 ++++++++++++++++++++++++++++++--
 lodash/lodash-tests.ts | 12 ++++++++++++
 2 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/lodash/index.d.ts b/lodash/index.d.ts
index 678e0c58b9..95d6a83c8e 100644
--- a/lodash/index.d.ts
+++ b/lodash/index.d.ts
@@ -68,7 +68,7 @@ added 23 array methods:
 - [x] _.xorBy
 - [x] _.xorWith
 
-added 18 lang methods:
+added 20 lang methods:
 - [x] _.cloneDeepWith
 - [x] _.cloneWith
 - [x] _.eq
@@ -87,6 +87,8 @@ added 18 lang methods:
 - [x] _.toNumber
 - [x] _.toSafeInteger
 - [x] _.toString
+- [X] _.conforms
+- [X] _.conformsTo
 
 added 13 object methods:
 - [x] _.assignIn
@@ -225,7 +227,6 @@ Methods:
 - [ ] _.split
 
 - [ ] _.cond
-- [ ] _.conforms
 - [ ] _.nthArg
 - [ ] _.over
 - [ ] _.overEvery
@@ -11432,6 +11433,33 @@ declare namespace _ {
         ): LoDashExplicitObjectWrapper<TResult>;
     }
 
+    /**
+     * An object containing predicate functions for each property of T
+     */
+    type ConformsPredicateObject<T> = {
+        [P in keyof T]: (val: T[P]) => boolean;
+    };
+
+    //_.conforms
+    interface LoDashStatic {
+        /**
+         * Creates a function that invokes the predicate properties of `source` with the corresponding
+         * property values of a given object, returning true if all predicates return truthy, else false.
+         */
+        conforms<T>(source: ConformsPredicateObject<T>): (Target: T) => boolean;
+    }
+
+    //_.conformsTo
+    interface LoDashStatic {
+        /**
+         * Checks if object conforms to source by invoking the predicate properties of source with the
+         * corresponding property values of object.
+         *
+         * Note: This method is equivalent to _.conforms when source is partially applied.
+         */
+        conformsTo<T>(object: T, source: ConformsPredicateObject<T>): boolean;
+    }
+
     //_.eq
     interface LoDashStatic {
         /**
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index c1a5ca3e64..7d4d22d387 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -6488,6 +6488,18 @@ namespace TestCloneWith {
     }
 }
 
+// _.conforms
+namespace TestConforms {
+    let result: boolean = _.conforms({foo: (v: string) => false})({foo: "foo"});
+    let result2: boolean = _.conforms({})({foo: "foo"});
+}
+
+// _.conformsTo
+namespace TestConformsTo {
+    let result: boolean = _.conformsTo({foo: "foo"}, {foo: (v: string) => false});
+    let result2: boolean = _.conformsTo({}, {foo: (v: string) => false});
+}
+
 // _.eq
 namespace TestEq {
     let customizer: (value: any, other: any, indexOrKey?: number|string) => boolean;

From 12ab6e01e85adab2621fffd79d35ba2216425d39 Mon Sep 17 00:00:00 2001
From: Sheeo <sheeo@sheeo.dk>
Date: Fri, 27 Jan 2017 09:03:37 +0100
Subject: [PATCH 60/87] Use TypeScript Version 2.1

---
 lodash/index.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lodash/index.d.ts b/lodash/index.d.ts
index 95d6a83c8e..04341a94a8 100644
--- a/lodash/index.d.ts
+++ b/lodash/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /**
 ### 4.0.0 Changelog (https://github.com/lodash/lodash/wiki/Changelog)

From f0962440962a9f4b50e4669be5f0af5cae6dc34d Mon Sep 17 00:00:00 2001
From: akim95 <m.akmalhakim95@gmail.com>
Date: Fri, 27 Jan 2017 16:55:38 +0800
Subject: [PATCH 61/87] added type definitions for express-mysql-session 1.2

---
 .../express-mysql-session-tests.ts            |  13 ++
 express-mysql-session/index.d.ts              | 136 ++++++++++++++++++
 express-mysql-session/tsconfig.json           |  20 +++
 express-mysql-session/tslint.json             |   1 +
 4 files changed, 170 insertions(+)
 create mode 100644 express-mysql-session/express-mysql-session-tests.ts
 create mode 100644 express-mysql-session/index.d.ts
 create mode 100644 express-mysql-session/tsconfig.json
 create mode 100644 express-mysql-session/tslint.json

diff --git a/express-mysql-session/express-mysql-session-tests.ts b/express-mysql-session/express-mysql-session-tests.ts
new file mode 100644
index 0000000000..b69486dd8d
--- /dev/null
+++ b/express-mysql-session/express-mysql-session-tests.ts
@@ -0,0 +1,13 @@
+import MySQLStore = require('express-mysql-session');
+
+const options = {
+    host: 'localhost',
+    port: 3306,
+    user: 'root',
+    password: '',
+    database: 'session_test'
+};
+
+const sessionStore = new MySQLStore(options);
+
+sessionStore.close();
diff --git a/express-mysql-session/index.d.ts b/express-mysql-session/index.d.ts
new file mode 100644
index 0000000000..0e86b9b077
--- /dev/null
+++ b/express-mysql-session/index.d.ts
@@ -0,0 +1,136 @@
+// Type definitions for express-mysql-session 1.2
+// Project: https://github.com/chill117/express-mysql-session#readme
+// Definitions by: Akim95 <https://github.com/Akim95>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = MySQLStore;
+
+declare namespace MySQLStore {
+    interface Options {
+        host?: string;
+        port?: number;
+        user?: string;
+        password?: string;
+        database?: string;
+        checkExpirationInterval?: number;
+        expiration?: number;
+        createDatabaseTable?: boolean;
+        connectionLimit?: number;
+        schema?: Schema;
+    }
+    interface Schema {
+        tableName: string;
+        columnNames: ColumnNames;
+    }
+    interface ColumnNames {
+        session_id: string;
+        expires: string;
+        data: string;
+    }
+}
+
+declare class MySQLStore {
+
+    /**
+     * @param  {MySQLStore.Options} options
+     * @param  {any} connection?
+     * @param  {(error:any)=>void} callback?
+     */
+    constructor(options: MySQLStore.Options, connection?: any, callback?: (error: any) => void);
+
+    /**
+     * @returns void
+     */
+    setDefaultOptions(): void;
+
+    /**
+     * @param  {(error:any)=>void} callback?
+     * @returns void
+     */
+    createDatabaseTable(callback?: (error: any) => void): void;
+
+    /**
+     * @param  {string} sessionId
+     * @param  {(error:any,session:any)=>void} callback?
+     * @returns void
+     */
+    get(sessionId: string, callback?: (error: any, session: any) => void): void;
+
+    /**
+     * @param  {string} sessionId
+     * @param  {any} data
+     * @param  {(error:any)=>void} callback?
+     * @returns void
+     */
+    set(sessionId: string, data: any, callback?: (error: any) => void): void;
+
+    /**
+     * @param  {string} sessionId
+     * @param  {any} data
+     * @param  {(error:any)=>void} callback?
+     * @returns void
+     */
+    touch(sessionId: string, data: any, callback?: (error: any) => void): void;
+
+    /**
+     * @param  {string} sessionId
+     * @param  {(error:any)=>void} callback?
+     * @returns void
+     */
+    destroy(sessionId: string, callback?: (error: any) => void): void;
+
+    /**
+     * @param  {(error:any,count:any)=>void} callback?
+     * @returns void
+     */
+    length(callback?: (error: any, count: any) => void): void;
+
+    /**
+     * @param  {(error:any)=>void} callback?
+     * @returns void
+     */
+    clear(callback?: (error: any) => void): void;
+
+    /**
+     * @param  {(error:any)=>void} callback?
+     * @returns void
+     */
+    clearExpiredSessions(callback?: (error: any) => void): void;
+
+    /**
+     * @param  {number} interval
+     * @returns void
+     */
+    setExpirationInterval(interval: number): void;
+
+    /**
+     * @returns void
+     */
+    clearExpirationInterval(): void;
+
+    /**
+     * @param  {()=>void} callback?
+     * @returns void
+     */
+    close(callback?: () => void): void;
+
+    /**
+     * @param  {any} object
+     * @param  {any} defaultValues
+     * @param  {any} options?
+     * @returns void
+     */
+    default(object: any, defaultValues: any, options?: any): void;
+
+    /**
+     * @param  {any} object
+     * @returns void
+     */
+    clone(object: any): void;
+
+    /**
+     * @param  {any} value
+     * @returns void
+     */
+    isObject(value: any): void;
+}
diff --git a/express-mysql-session/tsconfig.json b/express-mysql-session/tsconfig.json
new file mode 100644
index 0000000000..5af8734c24
--- /dev/null
+++ b/express-mysql-session/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "express-mysql-session-tests.ts"
+    ]
+}
diff --git a/express-mysql-session/tslint.json b/express-mysql-session/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/express-mysql-session/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 30cecf0452820e606efb8bdc5d058cf4ba8d1612 Mon Sep 17 00:00:00 2001
From: Jason Dent <jason@Jasons-MacBook-Pro.local>
Date: Fri, 27 Jan 2017 10:42:03 +0100
Subject: [PATCH 62/87] Add Types for comment-json

---
 comment-json/comment-json-tests.ts | 16 ++++++++++++++++
 comment-json/index.d.ts            |  8 ++++++++
 comment-json/tsconfig.json         | 20 ++++++++++++++++++++
 comment-json/tslint.json           |  1 +
 4 files changed, 45 insertions(+)
 create mode 100644 comment-json/comment-json-tests.ts
 create mode 100644 comment-json/index.d.ts
 create mode 100644 comment-json/tsconfig.json
 create mode 100644 comment-json/tslint.json

diff --git a/comment-json/comment-json-tests.ts b/comment-json/comment-json-tests.ts
new file mode 100644
index 0000000000..af91ff422f
--- /dev/null
+++ b/comment-json/comment-json-tests.ts
@@ -0,0 +1,16 @@
+import * as commentJson from 'comment-json';
+
+const result = commentJson.parse(`
+/**
+ block comment at the top
+ */
+// comment at the top
+{
+  // comment for a
+  // comment line 2 for a
+  /* block comment */
+  "a": 1 // comment at right
+}
+// comment at the bottom
+`);
+const str = commentJson.stringify(result);
diff --git a/comment-json/index.d.ts b/comment-json/index.d.ts
new file mode 100644
index 0000000000..9c2652f34e
--- /dev/null
+++ b/comment-json/index.d.ts
@@ -0,0 +1,8 @@
+// Type definitions for comment-json 1.1
+// Project: https://github.com/kaelzhang/node-comment-json
+// Definitions by: Jason Dent <https://github.com/Jason3S>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export type Reviver = (k: number | string, v: any) => any;
+export function parse(json: string, reviver?: Reviver, removes_comments?: boolean): any;
+export function stringify(value: any, replacer?: any, space?: string | number): string;
diff --git a/comment-json/tsconfig.json b/comment-json/tsconfig.json
new file mode 100644
index 0000000000..342694cbb3
--- /dev/null
+++ b/comment-json/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "comment-json-tests.ts"
+    ]
+}
diff --git a/comment-json/tslint.json b/comment-json/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/comment-json/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 2d3c9f8fa6b9814ea1219f8bc8f165db52e357ec Mon Sep 17 00:00:00 2001
From: Patricio Zavolinsky <patricio.zavolinsky@emaint.com>
Date: Fri, 27 Jan 2017 10:26:01 +0000
Subject: [PATCH 63/87] react-input-mask and react-native-scrollable-tab-view:
 fix linter issues (trailing whitespace)

---
 react-input-mask/index.d.ts                 |  2 +-
 react-native-scrollable-tab-view/index.d.ts | 18 +++++++++---------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/react-input-mask/index.d.ts b/react-input-mask/index.d.ts
index 6fc8c6008f..c6acce5858 100644
--- a/react-input-mask/index.d.ts
+++ b/react-input-mask/index.d.ts
@@ -13,7 +13,7 @@ declare namespace reactInputMask {
          * * `9`: `0-9`
          * * `a`: `A-Z, a-z`
          * * `\*`: `A-Z, a-z, 0-9`
-         * 
+         *
          * Any character can be escaped with backslash, which usually will appear as double backslash in JS strings. For example, German phone mask with unremoveable prefix +49 will look like `mask="+4\\9 99 999 99"` or `mask={"+4\\\\9 99 999 99"}`
          */
         mask: string;
diff --git a/react-native-scrollable-tab-view/index.d.ts b/react-native-scrollable-tab-view/index.d.ts
index 2f22f1bcf4..9287ede79d 100644
--- a/react-native-scrollable-tab-view/index.d.ts
+++ b/react-native-scrollable-tab-view/index.d.ts
@@ -37,9 +37,9 @@ export interface renderTabBarProperties {
 interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
 
   /**
-   * tabBarPosition (String) Defaults to "top". 
+   * tabBarPosition (String) Defaults to "top".
    * "bottom" to position the tab bar below content.
-   * "overlayTop" or "overlayBottom" for a semitransparent tab bar that overlays content. Custom 
+   * "overlayTop" or "overlayBottom" for a semitransparent tab bar that overlays content. Custom
    * tab bars must consume a style prop on their outer element to support this feature: style={this.props.style}.
    */
   tabBarPosition?: 'top' | 'bottom' | 'overlayTop' | 'overlayBottom';
@@ -50,27 +50,27 @@ interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
   initialPage?: number;
 
   /**
-   * (Integer) - set selected tab(can be buggy see 
+   * (Integer) - set selected tab(can be buggy see
    * https://github.com/skv-headless/react-native-scrollable-tab-view/issues/126
    */
   page?: number;
 
   /**
-   * onChangeTab (Function) - function to call when tab changes, should accept 1 argument which is 
-   * an Object containing two keys: i: the index of the tab that is selected, ref: the ref of the 
+   * onChangeTab (Function) - function to call when tab changes, should accept 1 argument which is
+   * an Object containing two keys: i: the index of the tab that is selected, ref: the ref of the
    * tab that is selected
    */
   onChangeTab?: (value: onChangeTabProperties) => void;
 
   /**
-   * onScroll (Function) - function to call when the pages are sliding, 
+   * onScroll (Function) - function to call when the pages are sliding,
    * should accept 1 argument which is an Float number representing the page position in the slide frame.
    */
   onScroll?: (value: number) => void;
 
   /**
    * renderTabBar (Function:ReactComponent) - accept 1 argument props and should return a component
-   * to use as the tab bar. The component has goToPage, tabs, activeTab and ref added to the props, 
+   * to use as the tab bar. The component has goToPage, tabs, activeTab and ref added to the props,
    * and should implement setAnimationValue to be able to animate itself along with the tab content.
    * You can manually pass the props to the TabBar component.
    */
@@ -82,7 +82,7 @@ interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
   style?: ViewStyle;
 
   /**
-   * contentProps (Object) - props that are applied to root ScrollView/ViewPagerAndroid. 
+   * contentProps (Object) - props that are applied to root ScrollView/ViewPagerAndroid.
    * Note that overriding defaults set by the library may break functionality; see the source for details.
    */
   contentProps?: React.ScrollViewProperties;
@@ -98,7 +98,7 @@ interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
   locked?: boolean;
 
   /**
-   * prerenderingSiblingsNumber (Integer) - pre-render nearby # sibling, Infinity === render all 
+   * prerenderingSiblingsNumber (Integer) - pre-render nearby # sibling, Infinity === render all
    * the siblings, default to 0 === render current page.
    */
   prerenderingSiblingsNumber?: number;

From 70a11f0ffe423cdaf4d777ae8a6c375c94b09516 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Fri, 27 Jan 2017 16:02:57 +0200
Subject: [PATCH 64/87] Pino - update Logger Options and add levelVal

---
 pino/index.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pino/index.d.ts b/pino/index.d.ts
index 6273d2fc65..a9c4b949e2 100644
--- a/pino/index.d.ts
+++ b/pino/index.d.ts
@@ -59,7 +59,8 @@ declare namespace P {
         extreme?: boolean;
         // enables logging, defaults to true.
         enabled?: boolean;
-        level?: Level;
+        level?: Level | string;
+        levelVal?: number;
     }
 
     interface Pino {

From d9f74ddaa65574050f8d7e71503a91cef9f165c2 Mon Sep 17 00:00:00 2001
From: Yaroslav Serhieiev <noomorph@gmail.com>
Date: Wed, 25 Jan 2017 11:31:32 +0200
Subject: [PATCH 65/87] angular: added tslint validation to the folder; made
 the code compliant to tslint

---
 angular-gridster/index.d.ts           |   8 +-
 angular/angular-component-router.d.ts |   4 +-
 angular/angular-tests.ts              | 448 +++++++++++++-------------
 angular/index.d.ts                    |  91 +++---
 angular/tslint.json                   |  20 ++
 5 files changed, 294 insertions(+), 277 deletions(-)
 create mode 100644 angular/tslint.json

diff --git a/angular-gridster/index.d.ts b/angular-gridster/index.d.ts
index de60d6377b..fc0e990d41 100644
--- a/angular-gridster/index.d.ts
+++ b/angular-gridster/index.d.ts
@@ -32,7 +32,7 @@ declare module "angular" {
             // width of grid columns. "auto" will divide the width of the grid evenly among the columns
             colWidth?: string;
 
-            // height of grid rows. 'match' will make it the same as the column width, a numeric value will be interpreted as pixels, 
+            // height of grid rows. 'match' will make it the same as the column width, a numeric value will be interpreted as pixels,
             // '/2' is half the column width, '*5' is five times the column width, etc.
             rowHeight?: string;
 
@@ -84,7 +84,7 @@ declare module "angular" {
             // options to pass to resizable handler
             resizable?: {
 
-                // whether the items are resizable 
+                // whether the items are resizable
                 enabled?: boolean;
 
                 // location of the resize handles
@@ -104,7 +104,7 @@ declare module "angular" {
             // options to pass to draggable handler
             draggable?: {
 
-                // whether the items are resizable 
+                // whether the items are resizable
                 enabled?: boolean;
 
                 // Distance in pixels from the edge of the viewport after which the viewport should scroll, relative to pointer
@@ -142,4 +142,4 @@ declare module "angular" {
             col: number;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/angular/angular-component-router.d.ts b/angular/angular-component-router.d.ts
index 99ae821c72..92458331d6 100644
--- a/angular/angular-component-router.d.ts
+++ b/angular/angular-component-router.d.ts
@@ -1,9 +1,9 @@
+/* tslint:disable:dt-header variable-name */
 // Type definitions for Angular JS 1.5 component router
 // Project: http://angularjs.org
 // Definitions by: David Reher <http://github.com/davidreher>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-
 declare namespace angular {
     /**
      * `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed
@@ -263,7 +263,7 @@ declare namespace angular {
         /**
          * Subscribe to URL updates from the router
          */
-        subscribe(onNext: (value: any) => void): Object;
+        subscribe(onNext: (value: any) => void): {};
 
         /**
          * Removes the contents of this router's outlet and all descendant outlets
diff --git a/angular/angular-tests.ts b/angular/angular-tests.ts
index c6ee7c7a00..1a4841ab8c 100644
--- a/angular/angular-tests.ts
+++ b/angular/angular-tests.ts
@@ -1,4 +1,3 @@
-
 // issue: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/369
 // https://github.com/witoldsz/angular-http-auth/blob/master/src/angular-http-auth.js
 /**
@@ -7,12 +6,14 @@
  * License: MIT
  */
 
+/* tslint:disable:no-empty no-shadowed-variable */
+
 class AuthService {
     /**
       * Holds all the requests which failed due to 401 response,
       * so they can be re-requested in future, once login is completed.
       */
-    buffer: { config: ng.IRequestConfig; deferred: ng.IDeferred<any>; }[] = [];
+    buffer: Array<{ config: ng.IRequestConfig; deferred: ng.IDeferred<any>; }> = [];
 
     /**
      * Required by HTTP interceptor.
@@ -20,34 +21,35 @@ class AuthService {
      */
     pushToBuffer = function(config: ng.IRequestConfig, deferred: ng.IDeferred<any>) {
         this.buffer.push({
-            config: config,
-            deferred: deferred
+            config,
+            deferred
         });
-    }
+    };
 
     $get = [
-        '$rootScope', '$injector', <any>function($rootScope: ng.IScope, $injector: ng.auto.IInjectorService) {
-            var $http: ng.IHttpService; //initialized later because of circular dependency problem
+        '$rootScope', '$injector', function($rootScope: ng.IScope, $injector: ng.auto.IInjectorService) {
+            let $http: ng.IHttpService; //initialized later because of circular dependency problem
             function retry(config: ng.IRequestConfig, deferred: ng.IDeferred<any>) {
                 $http = $http || $injector.get<ng.IHttpService>('$http');
-                $http(config).then(function (response) {
+                $http(config).then(function(response) {
                     deferred.resolve(response);
                 });
             }
             function retryAll() {
-                for (var i = 0; i < this.buffer.length; ++i) {
-                    retry(this.buffer[i].config, this.buffer[i].deferred);
+                for (const request of this.buffer) {
+                    retry(request.config, request.deferred);
                 }
+
                 this.buffer = [];
             }
 
             return {
-                loginConfirmed: function () {
+                loginConfirmed() {
                     $rootScope.$broadcast('event:auth-loginConfirmed');
                     retryAll();
                 }
-            }
-        }
+            };
+        } as any
     ];
 }
 
@@ -59,20 +61,20 @@ angular.module('http-auth-interceptor', [])
  * $http interceptor.
  * On 401 response - it stores the request and broadcasts 'event:angular-auth-loginRequired'.
  */
-    .config(['$httpProvider', 'authServiceProvider', <any>function ($httpProvider: ng.IHttpProvider, authServiceProvider: any) {
+    .config(['$httpProvider', 'authServiceProvider', function($httpProvider: ng.IHttpProvider, authServiceProvider: any) {
 
-        $httpProvider.defaults.headers.common = {'Authorization': 'Bearer token'};
+        $httpProvider.defaults.headers.common = {Authorization: 'Bearer token'};
         $httpProvider.defaults.headers.get['Authorization'] = 'Bearer token';
-        $httpProvider.defaults.headers.post['Authorization'] = function (config:ng.IRequestConfig):string { return 'Bearer token'; }
+        $httpProvider.defaults.headers.post['Authorization'] = function(config: ng.IRequestConfig): string { return 'Bearer token'; };
 
-        var interceptor = ['$rootScope', '$q', <any>function ($rootScope: ng.IScope, $q: ng.IQService) {
+        const interceptor = ['$rootScope', '$q', function($rootScope: ng.IScope, $q: ng.IQService) {
             function success(response: ng.IHttpPromiseCallbackArg<any>) {
                 return response;
             }
 
             function error(response: ng.IHttpPromiseCallbackArg<any>) {
                 if (response.status === 401) {
-                    var deferred = $q.defer<void>();
+                    const deferred = $q.defer<void>();
                     authServiceProvider.pushToBuffer(response.config, deferred);
                     $rootScope.$broadcast('event:auth-loginRequired');
                     return deferred.promise;
@@ -81,14 +83,13 @@ angular.module('http-auth-interceptor', [])
                 return $q.reject(response);
             }
 
-          return function (promise: ng.IHttpPromise<any>) {
+          return function(promise: ng.IHttpPromise<any>) {
                 return promise.then(success, error);
-            }
+            };
 
-      }];
+      } as any];
         $httpProvider.interceptors.push(interceptor);
-    }]);
-
+    } as any]);
 
 namespace HttpAndRegularPromiseTests {
     interface Person {
@@ -96,7 +97,7 @@ namespace HttpAndRegularPromiseTests {
         lastName: string;
     }
 
-    interface ExpectedResponse extends Person { }
+    type ExpectedResponse = Person;
 
     interface SomeControllerScope extends ng.IScope {
         person: Person;
@@ -106,13 +107,13 @@ namespace HttpAndRegularPromiseTests {
         nothing?: string;
     }
 
-    var someController: Function = ($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) => {
-        $http.get<ExpectedResponse>("http://somewhere/some/resource")
+    function someController($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) {
+        $http.get<ExpectedResponse>('http://somewhere/some/resource')
             .success((data: ExpectedResponse) => {
                 $scope.person = data;
             });
 
-        $http.get<ExpectedResponse>("http://somewhere/some/resource")
+        $http.get<ExpectedResponse>('http://somewhere/some/resource')
             .then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
                 // typing lost, so something like
                 // var i: number = response.data
@@ -120,7 +121,7 @@ namespace HttpAndRegularPromiseTests {
                 $scope.person = response.data;
             });
 
-        $http.get<ExpectedResponse>("http://somewhere/some/resource")
+        $http.get<ExpectedResponse>('http://somewhere/some/resource')
             .then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
                 // typing lost, so something like
                 // var i: number = response.data
@@ -128,47 +129,48 @@ namespace HttpAndRegularPromiseTests {
                 $scope.person = response.data;
             });
 
-        var aPromise: ng.IPromise<Person> = $q.when({ firstName: "Jack", lastName: "Sparrow" });
+        const aPromise: ng.IPromise<Person> = $q.when({ firstName: 'Jack', lastName: 'Sparrow' });
         aPromise.then((person: Person) => {
             $scope.person = person;
         });
 
-        var bPromise: ng.IPromise<number> = $q.when(42);
+        const bPromise: ng.IPromise<number> = $q.when(42);
         bPromise.then((answer: number) => {
             $scope.theAnswer = answer;
         });
 
-        var cPromise: ng.IPromise<string[]> = $q.when(["a", "b", "c"]);
+        const cPromise: ng.IPromise<string[]> = $q.when(['a', 'b', 'c']);
         cPromise.then((letters: string[]) => {
             $scope.letters = letters;
         });
 
         // When $q.when is passed an IPromise<T>, it returns an IPromise<T>
-        var dPromise: ng.IPromise<string> = $q.when($q.when("ALBATROSS!"));
+        const dPromise: ng.IPromise<string> = $q.when($q.when('ALBATROSS!'));
         dPromise.then((snack: string) => {
             $scope.snack = snack;
         });
 
         // $q.when may be called without arguments
-        var ePromise: ng.IPromise<void> = $q.when();
+        const ePromise: ng.IPromise<void> = $q.when();
         ePromise.then(() => {
-            $scope.nothing = "really nothing";
+            $scope.nothing = 'really nothing';
         });
     }
 
-  // Test that we can pass around a type-checked success/error Promise Callback
-  var anotherController: Function = ($scope: SomeControllerScope, $http:
-        ng.IHttpService, $q: ng.IQService) => {
-
-        var buildFooData: Function = () => 42;
-
-        var doFoo: Function = (callback: ng.IHttpPromiseCallback<ExpectedResponse>) => {
-            $http.get<ExpectedResponse>('/foo', buildFooData())
-                .success(callback);
+    // Test that we can pass around a type-checked success/error Promise Callback
+    function anotherController($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) {
+        function buildFooData(): ng.IRequestShortcutConfig {
+            return {};
         }
 
-    doFoo((data: any) => console.log(data));
-    }
+        function doFoo(callback: ng.IHttpPromiseCallback<ExpectedResponse>) {
+            $http
+                .get<ExpectedResponse>('/foo', buildFooData())
+                .success(callback);
+        };
+
+        doFoo((data: any) => console.log(data));
+    };
 }
 
 // Test for AngularJS Syntax
@@ -178,9 +180,9 @@ namespace My.Namespace {
 }
 
 // IModule Registering Test
-var mod = angular.module('tests', []);
-mod.controller('name', function ($scope: ng.IScope) { });
-mod.controller('name', ['$scope', function ($scope: ng.IScope) { }]);
+let mod = angular.module('tests', []);
+mod.controller('name', function($scope: ng.IScope) { });
+mod.controller('name', ['$scope', function($scope: ng.IScope) { }]);
 mod.controller('name', class {
     // Uncommenting the next line should lead to a type error because this signature isn't compatible
     // with the signature of the `$onChanges` hook:
@@ -188,7 +190,7 @@ mod.controller('name', class {
 });
 mod.controller({
     MyCtrl: class{},
-    MyCtrl2: function() {},
+    MyCtrl2: function() {}, // tslint:disable-line:object-literal-shorthand
     MyCtrl3: ['$fooService', function($fooService: any) { }]
 });
 mod.directive('myDirectiveA', ($rootScope: ng.IRootScopeService) => {
@@ -201,7 +203,7 @@ mod.directive('myDirectiveA', ($rootScope: ng.IRootScopeService) => {
         scope.$watch(() => foo, () => el.text(foo));
     };
 });
-mod.directive('myDirectiveB', ['$rootScope', function ($rootScope: ng.IRootScopeService) {
+mod.directive('myDirectiveB', ['$rootScope', function($rootScope: ng.IRootScopeService) {
     return {
         link(scope, el, attrs) {
             el.click(e => {
@@ -218,38 +220,37 @@ mod.directive({
         template: 'my-bar-dir.tpl.html'
     })]
 });
-mod.factory('name', function ($scope: ng.IScope) { })
-mod.factory('name', ['$scope', function ($scope: ng.IScope) { }])
+mod.factory('name', function($scope: ng.IScope) { });
+mod.factory('name', ['$scope', function($scope: ng.IScope) { }]);
 mod.factory({
-    name1: function (foo: any) { },
-    name2: ['foo', function (foo: any) { }]
+    name1: function(foo: any) { }, // tslint:disable-line:object-literal-shorthand
+    name2: ['foo', function(foo: any) { }]
 });
-mod.filter('name', function ($scope: ng.IScope) { })
-mod.filter('name', ['$scope', function ($scope: ng.IScope) { }])
+mod.filter('name', function($scope: ng.IScope) { });
+mod.filter('name', ['$scope', function($scope: ng.IScope) { }]);
 mod.filter({
-    name1: function (foo: any) { },
-    name2: ['foo', function (foo: any) { }]
+    name1: function(foo: any) { }, // tslint:disable-line:object-literal-shorthand
+    name2: ['foo', function(foo: any) { }]
 });
-mod.provider('name', function ($scope: ng.IScope) { return { $get: () => { } } })
+mod.provider('name', function($scope: ng.IScope) { return { $get: () => { } }; });
 mod.provider('name', TestProvider);
-mod.provider('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.provider('name', ['$scope', function($scope: ng.IScope) { } as any]);
 mod.provider(My.Namespace);
-mod.service('name', function ($scope: ng.IScope) { })
-mod.service('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.service('name', function($scope: ng.IScope) { });
+mod.service('name', ['$scope', function($scope: ng.IScope) { } as any]);
 mod.service({
     MyCtrl: class{},
-    MyCtrl2: function() {},
+    MyCtrl2: function() {}, // tslint:disable-line:object-literal-shorthand
     MyCtrl3: ['$fooService', function($fooService: any) { }]
 });
 mod.constant('name', 23);
-mod.constant('name', "23");
+mod.constant('name', '23');
 mod.constant(My.Namespace);
 mod.value('name', 23);
-mod.value('name', "23");
+mod.value('name', '23');
 mod.value(My.Namespace);
-mod.decorator('name', function($scope:ng.IScope){ });
-mod.decorator('name', ['$scope', <any>function($scope: ng.IScope){ }]);
-
+mod.decorator('name', function($scope: ng.IScope) {});
+mod.decorator('name', ['$scope', function($scope: ng.IScope) {} as any]);
 
 class TestProvider implements ng.IServiceProvider {
     constructor(private $scope: ng.IScope) {
@@ -261,23 +262,23 @@ class TestProvider implements ng.IServiceProvider {
 
 // QProvider tests
 angular.module('qprovider-test', [])
-    .config(['$qProvider', function ($qProvider: ng.IQProvider) {
+    .config(['$qProvider', function($qProvider: ng.IQProvider) {
         const provider: ng.IQProvider = $qProvider.errorOnUnhandledRejections(false);
         const currentValue: boolean = $qProvider.errorOnUnhandledRejections();
     }]);
 
 // Promise signature tests
-var foo: ng.IPromise<number>;
+let foo: ng.IPromise<number>;
 foo.then((x) => {
     // x is inferred to be a number
-    return "asdf";
+    return 'asdf';
 }).then((x) => {
     // x is inferred to be string
-    x.length;
+    const len = x.length;
     return 123;
 }).then((x) => {
     // x is infered to be a number
-    x.toFixed();
+    const fixed = x.toFixed();
     return;
 }).then((x) => {
     // x is infered to be void
@@ -336,15 +337,14 @@ namespace TestQ {
         result = $q.all<TResult>([promiseAny, promiseAny]);
     }
     {
-        let result: angular.IPromise<{[id: string]: any;}>;
+        let result: angular.IPromise<{[id: string]: any; }>;
         result = $q.all({a: promiseAny, b: promiseAny});
     }
     {
-        let result: angular.IPromise<{a: number; b: string;}>;
-        result = $q.all<{a: number; b: string;}>({a: promiseAny, b: promiseAny});
+        let result: angular.IPromise<{a: number; b: string; }>;
+        result = $q.all<{a: number; b: string; }>({a: promiseAny, b: promiseAny});
     }
 
-
     // $q.defer
     {
         let result: angular.IDeferred<TResult>;
@@ -397,11 +397,10 @@ namespace TestQ {
     }
 }
 
-
-var httpFoo: ng.IHttpPromise<number>;
+let httpFoo: ng.IHttpPromise<number>;
 httpFoo.then((x) => {
     // When returning a promise the generic type must be inferred.
-    var innerPromise : ng.IPromise<number>;
+    var innerPromise: ng.IPromise<number>;
     return innerPromise;
 }).then((x) => {
     // must still be number.
@@ -409,13 +408,12 @@ httpFoo.then((x) => {
 });
 
 httpFoo.success((data, status, headers, config) => {
-    var h = headers("test");
+    const h = headers('test');
     h.charAt(0);
-    var hs = headers();
-    hs["content-type"].charAt(1);
+    const hs = headers();
+    hs['content-type'].charAt(1);
 });
 
-
 // Deferred signature tests
 namespace TestDeferred {
     var any: any;
@@ -432,8 +430,8 @@ namespace TestDeferred {
     // deferred.resolve
     {
         let result: void;
-        result = <void>deferred.resolve();
-        result = <void>deferred.resolve(tResult);
+        result = deferred.resolve() as void;
+        result = deferred.resolve(tResult) as void;
     }
 
     // deferred.reject
@@ -458,7 +456,7 @@ namespace TestDeferred {
 }
 
 namespace TestInjector {
-    let $injector: angular.auto.IInjectorService;
+    var $injector: angular.auto.IInjectorService;
 
     $injector.strictDi = true;
 
@@ -466,10 +464,9 @@ namespace TestInjector {
     $injector.annotate(() => {}, true);
 }
 
-
 // Promise signature tests
 namespace TestPromise {
-    var result: any;
+    let result: any;
     var any: any;
 
     interface TResult {
@@ -494,63 +491,61 @@ namespace TestPromise {
     var promise: angular.IPromise<TResult>;
 
     // promise.then
-    result = <angular.IPromise<any>>promise.then((result) => any);
-    result = <angular.IPromise<any>>promise.then((result) => any, (any) => any);
-    result = <angular.IPromise<any>>promise.then((result) => any, (any) => any, (any) => any);
+    result = promise.then((result) => any) as angular.IPromise<any>;
+    result = promise.then((result) => any, (any) => any) as angular.IPromise<any>;
+    result = promise.then((result) => any, (any) => any, (any) => any) as angular.IPromise<any>;
 
-    result = <angular.IPromise<TResult>>promise.then((result) => result);
-    result = <angular.IPromise<TResult>>promise.then((result) => result, (any) => any);
-    result = <angular.IPromise<TResult>>promise.then((result) => result, (any) => any, (any) => any);
-    result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise);
-    result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise, (any) => any);
-    result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise, (any) => any, (any) => any);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise, (any) => any);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise, (any) => any, (any) => any);
+    result = promise.then((result) => result) as angular.IPromise<TResult>;
+    result = promise.then((result) => result, (any) => any) as angular.IPromise<TResult>;
+    result = promise.then((result) => result, (any) => any, (any) => any) as angular.IPromise<TResult>;
+    result = promise.then((result) => tresultPromise) as angular.IPromise<TResult>;
+    result = promise.then((result) => tresultPromise, (any) => any) as angular.IPromise<TResult>;
+    result = promise.then((result) => tresultPromise, (any) => any, (any) => any) as angular.IPromise<TResult>;
+    result = promise.then((result) => tresultHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
+    result = promise.then((result) => tresultHttpPromise, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
+    result = promise.then((result) => tresultHttpPromise, (any) => any, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
 
-    result = <angular.IPromise<TOther>>promise.then((result) => tother);
-    result = <angular.IPromise<TOther>>promise.then((result) => tother, (any) => any);
-    result = <angular.IPromise<TOther>>promise.then((result) => tother, (any) => any, (any) => any);
-    result = <angular.IPromise<TOther>>promise.then((result) => totherPromise);
-    result = <angular.IPromise<TOther>>promise.then((result) => totherPromise, (any) => any);
-    result = <angular.IPromise<TOther>>promise.then((result) => totherPromise, (any) => any, (any) => any);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise, (any) => any);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise, (any) => any, (any) => any);
+    result = promise.then((result) => tother) as angular.IPromise<TOther>;
+    result = promise.then((result) => tother, (any) => any) as angular.IPromise<TOther>;
+    result = promise.then((result) => tother, (any) => any, (any) => any) as angular.IPromise<TOther>;
+    result = promise.then((result) => totherPromise) as angular.IPromise<TOther>;
+    result = promise.then((result) => totherPromise, (any) => any) as angular.IPromise<TOther>;
+    result = promise.then((result) => totherPromise, (any) => any, (any) => any) as angular.IPromise<TOther>;
+    result = promise.then((result) => totherHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
+    result = promise.then((result) => totherHttpPromise, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
+    result = promise.then((result) => totherHttpPromise, (any) => any, (any) => any) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
 
     // promise.catch
-    result = <angular.IPromise<any>>promise.catch((err) => any);
-    result = <angular.IPromise<TResult>>promise.catch((err) => tresult);
-    result = <angular.IPromise<TResult>>promise.catch((err) => tresultPromise);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.catch((err) => tresultHttpPromise);
-    result = <angular.IPromise<TOther>>promise.catch((err) => tother);
-    result = <angular.IPromise<TOther>>promise.catch((err) => totherPromise);
-    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.catch((err) => totherHttpPromise);
+    result = promise.catch((err) => any) as angular.IPromise<any>;
+    result = promise.catch((err) => tresult) as angular.IPromise<TResult>;
+    result = promise.catch((err) => tresultPromise) as angular.IPromise<TResult>;
+    result = promise.catch((err) => tresultHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>;
+    result = promise.catch((err) => tother) as angular.IPromise<TOther>;
+    result = promise.catch((err) => totherPromise) as angular.IPromise<TOther>;
+    result = promise.catch((err) => totherHttpPromise) as angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>;
 
     // promise.finally
-    result = <angular.IPromise<TResult>>promise.finally(() => any);
-    result = <angular.IPromise<TResult>>promise.finally(() => tresult);
-    result = <angular.IPromise<TResult>>promise.finally(() => tother);
+    result = promise.finally(() => any) as angular.IPromise<TResult>;
+    result = promise.finally(() => tresult) as angular.IPromise<TResult>;
+    result = promise.finally(() => tother) as angular.IPromise<TResult>;
 }
 
-
 function test_angular_forEach() {
-    var values: { [key: string]: string } = { name: 'misko', gender: 'male' };
-    var log: string[] = [];
-    angular.forEach(values, function (value, key) {
+    const values: { [key: string]: string } = { name: 'misko', gender: 'male' };
+    const log: string[] = [];
+    angular.forEach(values, function(value, key) {
         this.push(key + ': ' + value);
     }, log);
     //expect(log).toEqual(['name: misko', 'gender: male']);
 }
 
 // angular.element() tests
-var element = angular.element("div.myApp");
-var scope: ng.IScope = element.scope();
-var isolateScope: ng.IScope = element.isolateScope();
+let element = angular.element('div.myApp');
+let scope: ng.IScope = element.scope();
+let isolateScope: ng.IScope = element.isolateScope();
 isolateScope = element.find('div.foo').isolateScope();
 isolateScope = element.children().isolateScope();
 
-
 // $timeout signature tests
 namespace TestTimeout {
     interface TResult {
@@ -590,25 +585,24 @@ namespace TestTimeout {
     }
 }
 
-
-function test_IAttributes(attributes: ng.IAttributes){
+function test_IAttributes(attributes: ng.IAttributes) {
     return attributes;
 }
 
 test_IAttributes({
-    $normalize: function (classVal){ return "foo" },
-    $addClass: function (classVal){},
-    $removeClass: function(classVal){},
-    $updateClass: function(newClass, oldClass){},
-    $set: function(key, value){},
-    $observe: function(name: any, fn: any){
+    $normalize(classVal) { return 'foo'; },
+    $addClass(classVal) {},
+    $removeClass(classVal) {},
+    $updateClass(newClass, oldClass) {},
+    $set(key, value) {},
+    $observe(name: any, fn: any) {
         return fn;
     },
     $attr: {}
 });
 
 class SampleDirective implements ng.IDirective {
-    public restrict = 'A';
+    restrict = 'A';
     name = 'doh';
 
     compile(templateElement: ng.IAugmentedJQuery) {
@@ -617,7 +611,7 @@ class SampleDirective implements ng.IDirective {
         };
     }
 
-    static instance():ng.IDirective {
+    static instance(): ng.IDirective {
         return new SampleDirective();
     }
 
@@ -627,7 +621,7 @@ class SampleDirective implements ng.IDirective {
 }
 
 class SampleDirective2 implements ng.IDirective {
-    public restrict = 'EAC';
+    restrict = 'EAC';
 
     compile(templateElement: ng.IAugmentedJQuery) {
         return {
@@ -635,7 +629,7 @@ class SampleDirective2 implements ng.IDirective {
         };
     }
 
-    static instance():ng.IDirective {
+    static instance(): ng.IDirective {
         return new SampleDirective2();
     }
 
@@ -654,7 +648,7 @@ angular.module('AnotherSampleDirective', []).directive('myDirective', ['$interpo
             $interpolate('', true)(scope);
             $interpolate('', true, 'html')(scope);
             $interpolate('', true, 'html', true)(scope);
-            var defer = $q.defer();
+            const defer = $q.defer();
             defer.reject();
             defer.resolve();
             defer.promise.then(function(d) {
@@ -670,7 +664,7 @@ angular.module('AnotherSampleDirective', []).directive('myDirective', ['$interpo
             .finally((): any => {
                 return null;
             });
-            var promise = new $q((resolve) => {
+            let promise = new $q((resolve) => {
                 resolve();
             });
 
@@ -785,25 +779,25 @@ angular.module('docsTimeDirective', [])
     .directive('myCurrentTime', ['$interval', 'dateFilter', function($interval: any, dateFilter: any) {
 
         return {
-            link: function(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs:ng.IAttributes) {
-                var format: any,
+            link(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) {
+                let format: any,
                     timeoutId: any;
 
                 function updateTime() {
                     element.text(dateFilter(new Date(), format));
                 }
 
-                scope.$watch(attrs['myCurrentTime'], function (value: any) {
+                scope.$watch(attrs['myCurrentTime'], function(value: any) {
                     format = value;
                     updateTime();
                 });
 
-                element.on('$destroy', function () {
+                element.on('$destroy', function() {
                     $interval.cancel(timeoutId);
                 });
 
                 // start the UI update process; save the timeoutId for canceling
-                timeoutId = $interval(function () {
+                timeoutId = $interval(function() {
                     updateTime(); // update DOM
                 }, 1000);
             }
@@ -832,19 +826,18 @@ angular.module('docsTransclusionExample', [])
             transclude: true,
             scope: {},
             templateUrl: 'my-dialog.html',
-            link: function (scope: ng.IScope, element: ng.IAugmentedJQuery) {
+            link(scope: ng.IScope, element: ng.IAugmentedJQuery) {
                 scope['name'] = 'Jeff';
             }
         };
     });
 
-
 angular.module('docsIsoFnBindExample', [])
     .controller('Controller', ['$scope', '$timeout', function($scope: any, $timeout: any) {
         $scope.name = 'Tobias';
-        $scope.hideDialog = function () {
+        $scope.hideDialog = function() {
             $scope.dialogIsHidden = true;
-            $timeout(function () {
+            $timeout(function() {
                 $scope.dialogIsHidden = false;
             }, 2000);
         };
@@ -854,7 +847,7 @@ angular.module('docsIsoFnBindExample', [])
             restrict: 'E',
             transclude: true,
             scope: {
-                'close': '&onClose'
+                close: '&onClose'
             },
             templateUrl: 'my-dialog-close.html'
         };
@@ -863,7 +856,7 @@ angular.module('docsIsoFnBindExample', [])
 angular.module('dragModule', [])
     .directive('myDraggable', ['$document', function($document: any) {
         return function(scope: any, element: any, attr: any) {
-            var startX = 0, startY = 0, x = 0, y = 0;
+            let startX = 0, startY = 0, x = 0, y = 0;
 
             element.css({
                 position: 'relative',
@@ -903,8 +896,8 @@ angular.module('docsTabsExample', [])
             restrict: 'E',
             transclude: true,
             scope: {},
-            controller: function($scope: ng.IScope) {
-                var panes: any = $scope['panes'] = [];
+            controller($scope: ng.IScope) {
+                const panes: any = $scope['panes'] = [];
 
                 $scope['select'] = function(pane: any) {
                     angular.forEach(panes, function(pane: any) {
@@ -931,7 +924,7 @@ angular.module('docsTabsExample', [])
             scope: {
                 title: '@'
             },
-            link: function(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes, tabsCtrl: any) {
+            link(scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes, tabsCtrl: any) {
                 tabsCtrl.addPane(scope);
             },
             templateUrl: 'my-pane.html'
@@ -945,7 +938,7 @@ angular.module('multiSlotTranscludeExample', [])
                 button: 'button',
                 list: 'ul',
             },
-            link: function(scope, element, attrs, ctrl, transclude) {
+            link(scope, element, attrs, ctrl, transclude) {
                 // without scope
                 transclude().appendTo(element);
                 transclude(clone => clone.appendTo(element));
@@ -960,52 +953,52 @@ angular.module('multiSlotTranscludeExample', [])
 
 angular.module('componentExample', [])
     .component('counter', {
-        require: {'ctrl': '^ctrl'},
+        require: {ctrl: '^ctrl'},
         bindings: {
             count: '='
         },
         controller: 'CounterCtrl',
         controllerAs: 'counterCtrl',
-        template: function () {
+        template() {
             return '';
         },
         transclude: {
-            'el': 'target'
+            el: 'target'
         }
     })
     .component('anotherCounter', {
-        controller: function(){},
+        controller() {},
         require: {
-            'parent': '^parentCtrl'
+            parent: '^parentCtrl'
         },
         template: '',
         transclude: true
     });
 
-interface copyExampleUser {
+interface ICopyExampleUser {
     name?: string;
     email?: string;
     gender?: string;
 }
 
-interface copyExampleScope {
+interface ICopyExampleScope {
 
-    user: copyExampleUser;
-    master: copyExampleUser;
-    update: (copyExampleUser: copyExampleUser) => any;
+    user: ICopyExampleUser;
+    master: ICopyExampleUser;
+    update: (copyExampleUser: ICopyExampleUser) => any;
     reset: () => any;
 }
 
 angular.module('copyExample', [])
-    .controller('ExampleController', ['$scope', function ($scope: copyExampleScope) {
+    .controller('ExampleController', ['$scope', function($scope: ICopyExampleScope) {
         $scope.master = { };
 
-        $scope.update = function (user) {
+        $scope.update = function(user) {
             // Example with 1 argument
             $scope.master = angular.copy(user);
         };
 
-        $scope.reset = function () {
+        $scope.reset = function() {
             // Example with 2 arguments
             angular.copy($scope.master, $scope.user);
         };
@@ -1022,9 +1015,14 @@ namespace locationTests {
      */
 
     // given url http://example.com/#/some/path?foo=bar&baz=xoxo
-    var searchObject = $location.search();
+    const searchObject = $location.search();
     // => {foo: 'bar', baz: 'xoxo'}
 
+    function assert(condition: boolean) {
+        if (!condition) {
+            throw new Error();
+        }
+    }
 
     // set foo to 'yipee'
     $location.search('foo', 'yipee');
@@ -1041,29 +1039,29 @@ namespace locationTests {
     // in browser with HTML5 history support:
     // open http://example.com/#!/a -> rewrite to http://example.com/a
     // (replacing the http://example.com/#!/a history record)
-    $location.path() == '/a'
+    assert($location.path() === '/a');
 
     $location.path('/foo');
-    $location.absUrl() == 'http://example.com/foo'
+    assert($location.absUrl() === 'http://example.com/foo');
 
-    $location.search() == {}
+    assert($location.search() === {});
     $location.search({ a: 'b', c: true });
-    $location.absUrl() == 'http://example.com/foo?a=b&c'
+    assert($location.absUrl() === 'http://example.com/foo?a=b&c');
 
     $location.path('/new').search('x=y');
-    $location.url() == 'new?x=y'
-    $location.absUrl() == 'http://example.com/new?x=y'
+    assert($location.url() === 'new?x=y');
+    assert($location.absUrl() === 'http://example.com/new?x=y');
 
     // in browser without html5 history support:
     // open http://example.com/new?x=y -> redirect to http://example.com/#!/new?x=y
     // (again replacing the http://example.com/new?x=y history item)
-    $location.path() == '/new'
-    $location.search() == { x: 'y' }
+    assert($location.path() === '/new');
+    assert($location.search() === { x: 'y' });
 
     $location.path('/foo/bar');
-    $location.path() == '/foo/bar'
-    $location.url() == '/foo/bar?x=y'
-    $location.absUrl() == 'http://example.com/#!/foo/bar?x=y'
+    assert($location.path() === '/foo/bar');
+    assert($location.url() === '/foo/bar?x=y');
+    assert($location.absUrl() === 'http://example.com/#!/foo/bar?x=y');
 }
 
 // NgModelController
@@ -1074,7 +1072,7 @@ function NgModelControllerTyping() {
 
     // See https://docs.angularjs.org/api/ng/type/ngModel.NgModelController#$validators
     ngModel.$validators['validCharacters'] = function(modelValue, viewValue) {
-        var value = modelValue || viewValue;
+        const value = modelValue || viewValue;
         return /[0-9]+/.test(value) &&
             /[a-z]+/.test(value) &&
             /[A-Z]+/.test(value) &&
@@ -1082,7 +1080,7 @@ function NgModelControllerTyping() {
     };
 
     ngModel.$asyncValidators['uniqueUsername'] = function(modelValue, viewValue) {
-        var value = modelValue || viewValue;
+        const value = modelValue || viewValue;
         return $http.get('/api/users/' + value).
             then(function resolved() {
                 return $q.reject('exists');
@@ -1092,67 +1090,67 @@ function NgModelControllerTyping() {
     };
 }
 
-var $filter: angular.IFilterService;
+let $filter: angular.IFilterService;
 
 function testFilter() {
 
     var items: string[];
-    $filter("filter")(items, "test");
-    $filter("filter")(items, {name: "test"});
-    $filter("filter")(items, (val, index, array) => {
+    $filter('filter')(items, 'test');
+    $filter('filter')(items, {name: 'test'});
+    $filter('filter')(items, (val, index, array) => {
         return true;
     });
-    $filter("filter")(items, (val, index, array) => {
+    $filter('filter')(items, (val, index, array) => {
       return true;
     }, (actual, expected) => {
-        return actual == expected;
+        return actual === expected;
     });
 }
 
 function testCurrency() {
-    $filter("currency")(126);
-    $filter("currency")(126, "$", 2);
+    $filter('currency')(126);
+    $filter('currency')(126, '$', 2);
 }
 
 function testNumber() {
-    $filter("number")(167);
-    $filter("number")(167, 2);
+    $filter('number')(167);
+    $filter('number')(167, 2);
 }
 
 function testDate() {
-    $filter("date")(new Date());
-    $filter("date")(new Date(), 'yyyyMMdd');
-    $filter("date")(new Date(), 'yyyyMMdd', '+0430');
+    $filter('date')(new Date());
+    $filter('date')(new Date(), 'yyyyMMdd');
+    $filter('date')(new Date(), 'yyyyMMdd', '+0430');
 }
 
 function testJson() {
-    var json: string = $filter("json")({test:true}, 2);
+    const json: string = $filter('json')({test: true}, 2);
 }
 
 function testLowercase() {
-    var lower: string = $filter("lowercase")('test');
+    const lower: string = $filter('lowercase')('test');
 }
 
 function testUppercase() {
-    var lower: string = $filter("uppercase")('test');
+    const lower: string = $filter('uppercase')('test');
 }
 
 function testLimitTo() {
-    var limitTo = $filter("limitTo");
-    var filtered: number[] = $filter("limitTo")([1,2,3], 5);
-    filtered = $filter("limitTo")([1,2,3], 5, 2);
+    const limitTo = $filter('limitTo');
+    let filtered: number[] = $filter('limitTo')([1, 2, 3], 5);
+    filtered = $filter('limitTo')([1, 2, 3], 5, 2);
 
-    var filteredString: string = $filter("limitTo")("124", 4);
-    filteredString = $filter("limitTo")(124, 4);
+    let filteredString: string = $filter('limitTo')('124', 4);
+    filteredString = $filter('limitTo')(124, 4);
 }
 
 function testOrderBy() {
-    var filtered: number[] = $filter("orderBy")([1,2,3], "test");
-    filtered = $filter("orderBy")([1,2,3], "test", true);
-    filtered = $filter("orderBy")([1,2,3], ['prop1', 'prop2']);
-    filtered = $filter("orderBy")([1,2,3], (val: number) => 1);
-    var filtered2: string[] = $filter("orderBy")(["1","2","3"], (val: string) => 1);
-    filtered2 = $filter("orderBy")(["1","2","3"], [
+    let filtered: number[] = $filter('orderBy')([1, 2, 3], 'test');
+    filtered = $filter('orderBy')([1, 2, 3], 'test', true);
+    filtered = $filter('orderBy')([1, 2, 3], ['prop1', 'prop2']);
+    filtered = $filter('orderBy')([1, 2, 3], (val: number) => 1);
+    let filtered2: string[] = $filter('orderBy')(['1', '2', '3'], (val: string) => 1);
+    filtered2 = $filter('orderBy')(['1', '2', '3'], [
         (val: string) => 1,
         (val: string) => 2
     ]);
@@ -1160,28 +1158,26 @@ function testOrderBy() {
 
 function testDynamicFilter() {
     // Test with separate variables
-    var dateFilter = $filter("date");
-    var myDate = new Date();
-    dateFilter(myDate , "EEE, MMM d");
+    const dateFilter = $filter('date');
+    const myDate = new Date();
+    dateFilter(myDate , 'EEE, MMM d');
 
     // Test with dynamic name
-    var filterName = 'date';
-    var dynDateFilter = $filter<ng.IFilterDate>(filterName);
+    const filterName = 'date';
+    const dynDateFilter = $filter<ng.IFilterDate>(filterName);
     dynDateFilter(new Date());
 }
 
-interface MyCustomFilter {
-    (value: string): string;
-}
+type MyCustomFilter = (value: string) => string;
 
 function testCustomFilter() {
-    var filterCustom = $filter<MyCustomFilter>('custom');
-    var filtered: string = filterCustom("test");
+    const filterCustom = $filter<MyCustomFilter>('custom');
+    const filtered: string = filterCustom('test');
 }
 
 function parseTyping() {
     var $parse: angular.IParseService;
-    var compiledExp = $parse('a.b.c');
+    const compiledExp = $parse('a.b.c');
     if (compiledExp.constant) {
         return compiledExp({});
     } else if (compiledExp.literal) {
@@ -1191,8 +1187,8 @@ function parseTyping() {
 
 function parseWithParams() {
     var $parse: angular.IParseService;
-    var compiledExp = $parse('a.b.c', () => null);
-    var compiledExp = $parse('a.b.c', null, false);
+    const compiledExp1 = $parse('a.b.c', () => null);
+    const compiledExp2 = $parse('a.b.c', null, false);
 }
 
 function doBootstrap(element: Element | JQuery, mode: string): ng.auto.IInjectorService {
@@ -1211,8 +1207,8 @@ function doBootstrap(element: Element | JQuery, mode: string): ng.auto.IInjector
 }
 
 function testIHttpParamSerializerJQLikeProvider() {
-    let serializer: angular.IHttpParamSerializer;
+    var serializer: angular.IHttpParamSerializer;
     serializer({
-        a: "b"
+        a: 'b'
     });
 }
diff --git a/angular/index.d.ts b/angular/index.d.ts
index f3f9fc87a6..3f094f3185 100644
--- a/angular/index.d.ts
+++ b/angular/index.d.ts
@@ -27,7 +27,7 @@ import ng = angular;
 ///////////////////////////////////////////////////////////////////////////////
 declare namespace angular {
 
-    type Injectable<T extends Function> = T | (string | T)[];
+    type Injectable<T extends Function> = T | Array<string | T>;
 
     // not directly implemented, but ensures that constructed class implements $get
     interface IServiceProviderClass {
@@ -64,7 +64,7 @@ declare namespace angular {
          * @param config an object for defining configuration options for the application. The following keys are supported:
          *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
          */
-        bootstrap(element: string|Element|JQuery|Document, modules?: (string|Function|any[])[], config?: IAngularBootstrapConfig): auto.IInjectorService;
+        bootstrap(element: string|Element|JQuery|Document, modules?: Array<string|Function|any[]>, config?: IAngularBootstrapConfig): auto.IInjectorService;
 
         /**
          * Creates a deep copy of source, which should be an object or an array.
@@ -122,7 +122,7 @@ declare namespace angular {
         fromJson(json: string): any;
         identity<T>(arg?: T): T;
         injector(modules?: any[], strictDi?: boolean): auto.IInjectorService;
-        isArray(value: any): value is Array<any>;
+        isArray(value: any): value is any[];
         isDate(value: any): value is Date;
         isDefined(value: any): boolean;
         isElement(value: any): boolean;
@@ -514,7 +514,7 @@ declare namespace angular {
         $watchCollection<T>(watchExpression: (scope: IScope) => T, listener: (newValue: T, oldValue: T, scope: IScope) => any): () => void;
 
         $watchGroup(watchExpressions: any[], listener: (newValue: any, oldValue: any, scope: IScope) => any): () => void;
-        $watchGroup(watchExpressions: { (scope: IScope): any }[], listener: (newValue: any, oldValue: any, scope: IScope) => any): () => void;
+        $watchGroup(watchExpressions: Array<{ (scope: IScope): any }>, listener: (newValue: any, oldValue: any, scope: IScope) => any): () => void;
 
         $parent: IScope;
         $root: IRootScopeService;
@@ -662,9 +662,9 @@ declare namespace angular {
     }
 
     interface IFilterOrderByItem {
-        value: any,
-        type: string,
-        index: any
+        value: any;
+        type: string;
+        index: any;
     }
 
     interface IFilterOrderByComparatorFunc {
@@ -756,7 +756,7 @@ declare namespace angular {
          * @param comparator Function used to determine the relative order of value pairs.
          * @return An array containing the items from the specified collection, ordered by a comparator function based on the values computed using the expression predicate.
          */
-        <T>(array: T[], expression: string|((value: T) => any)|(((value: T) => any)|string)[], reverse?: boolean, comparator?: IFilterOrderByComparatorFunc): T[];
+        <T>(array: T[], expression: string|((value: T) => any)|Array<((value: T) => any)|string>, reverse?: boolean, comparator?: IFilterOrderByComparatorFunc): T[];
     }
 
     /**
@@ -1023,7 +1023,7 @@ declare namespace angular {
         all<T1, T2, T3, T4>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>]): IPromise<[T1, T2, T3, T4]>;
         all<T1, T2, T3>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>]): IPromise<[T1, T2, T3]>;
         all<T1, T2>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>]): IPromise<[T1, T2]>;
-        all<TAll>(promises: IPromise<TAll>[]): IPromise<TAll[]>;
+        all<TAll>(promises: Array<IPromise<TAll>>): IPromise<TAll[]>;
         /**
          * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
          *
@@ -1284,11 +1284,11 @@ declare namespace angular {
     }
 
     interface ITemplateLinkingFunctionOptions {
-        parentBoundTranscludeFn?: ITranscludeFunction,
+        parentBoundTranscludeFn?: ITranscludeFunction;
         transcludeControllers?: {
             [controller: string]: { instance: IController }
-        },
-        futureParentElement?: JQuery
+        };
+        futureParentElement?: JQuery;
     }
 
     /**
@@ -1510,7 +1510,9 @@ declare namespace angular {
         (data: any, headersGetter: IHttpHeadersGetter, status: number): any;
     }
 
-    type HttpHeaderType = {[requestType: string]:string|((config:IRequestConfig) => string)};
+    interface HttpHeaderType {
+        [requestType: string]: string|((config: IRequestConfig) => string);
+    }
 
     interface IHttpRequestConfigHeaders {
         [requestType: string]: any;
@@ -1593,7 +1595,7 @@ declare namespace angular {
          * Register service factories (names or implementations) for interceptors which are called before and after
          * each request.
          */
-        interceptors: (string | Injectable<IHttpInterceptorFactory>)[];
+        interceptors: Array<string | Injectable<IHttpInterceptorFactory>>;
         useApplyAsync(): boolean;
         useApplyAsync(value: boolean): IHttpProvider;
 
@@ -1603,7 +1605,7 @@ declare namespace angular {
          * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.
          *    otherwise, returns the current configured value.
          */
-        useLegacyPromiseExtensions(value:boolean) : boolean | IHttpProvider;
+        useLegacyPromiseExtensions(value: boolean): boolean | IHttpProvider;
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -1687,16 +1689,15 @@ declare namespace angular {
         valueOf(value: any): any;
     }
 
-
     ///////////////////////////////////////////////////////////////////////////
     // SCEDelegateProvider
     // see http://docs.angularjs.org/api/ng.$sceDelegateProvider
     ///////////////////////////////////////////////////////////////////////////
     interface ISCEDelegateProvider extends IServiceProvider {
-        resourceUrlBlacklist(blacklist: any[]): void;
-        resourceUrlWhitelist(whitelist: any[]): void;
         resourceUrlBlacklist(): any[];
+        resourceUrlBlacklist(blacklist: any[]): void;
         resourceUrlWhitelist(): any[];
+        resourceUrlWhitelist(whitelist: any[]): void;
     }
 
     /**
@@ -1936,33 +1937,33 @@ declare namespace angular {
             annotate(fn: Function, strictDi?: boolean): string[];
             annotate(inlineAnnotatedFunction: any[]): string[];
             get<T>(name: string, caller?: string): T;
-            get(name: '$anchorScroll'): IAnchorScrollService
-            get(name: '$cacheFactory'): ICacheFactoryService
-            get(name: '$compile'): ICompileService
-            get(name: '$controller'): IControllerService
-            get(name: '$document'): IDocumentService
-            get(name: '$exceptionHandler'): IExceptionHandlerService
-            get(name: '$filter'): IFilterService
-            get(name: '$http'): IHttpService
-            get(name: '$httpBackend'): IHttpBackendService
-            get(name: '$httpParamSerializer'): IHttpParamSerializer
-            get(name: '$httpParamSerializerJQLike'): IHttpParamSerializer
-            get(name: '$interpolate'): IInterpolateService
-            get(name: '$interval'): IIntervalService
-            get(name: '$locale'): ILocaleService
-            get(name: '$location'): ILocationService
-            get(name: '$log'): ILogService
-            get(name: '$parse'): IParseService
-            get(name: '$q'): IQService
-            get(name: '$rootElement'): IRootElementService
-            get(name: '$rootScope'): IRootScopeService
-            get(name: '$sce'): ISCEService
-            get(name: '$sceDelegate'): ISCEDelegateService
-            get(name: '$templateCache'): ITemplateCacheService
-            get(name: '$templateRequest'): ITemplateRequestService
-            get(name: '$timeout'): ITimeoutService
-            get(name: '$window'): IWindowService
-            get<T>(name: '$xhrFactory'): IXhrFactory<T>
+            get(name: '$anchorScroll'): IAnchorScrollService;
+            get(name: '$cacheFactory'): ICacheFactoryService;
+            get(name: '$compile'): ICompileService;
+            get(name: '$controller'): IControllerService;
+            get(name: '$document'): IDocumentService;
+            get(name: '$exceptionHandler'): IExceptionHandlerService;
+            get(name: '$filter'): IFilterService;
+            get(name: '$http'): IHttpService;
+            get(name: '$httpBackend'): IHttpBackendService;
+            get(name: '$httpParamSerializer'): IHttpParamSerializer;
+            get(name: '$httpParamSerializerJQLike'): IHttpParamSerializer;
+            get(name: '$interpolate'): IInterpolateService;
+            get(name: '$interval'): IIntervalService;
+            get(name: '$locale'): ILocaleService;
+            get(name: '$location'): ILocationService;
+            get(name: '$log'): ILogService;
+            get(name: '$parse'): IParseService;
+            get(name: '$q'): IQService;
+            get(name: '$rootElement'): IRootElementService;
+            get(name: '$rootScope'): IRootScopeService;
+            get(name: '$sce'): ISCEService;
+            get(name: '$sceDelegate'): ISCEDelegateService;
+            get(name: '$templateCache'): ITemplateCacheService;
+            get(name: '$templateRequest'): ITemplateRequestService;
+            get(name: '$timeout'): ITimeoutService;
+            get(name: '$window'): IWindowService;
+            get<T>(name: '$xhrFactory'): IXhrFactory<T>;
             has(name: string): boolean;
             instantiate<T>(typeConstructor: Function, locals?: any): T;
             invoke(inlineAnnotatedFunction: any[]): any;
diff --git a/angular/tslint.json b/angular/tslint.json
new file mode 100644
index 0000000000..75f86620b4
--- /dev/null
+++ b/angular/tslint.json
@@ -0,0 +1,20 @@
+{
+  "extends": "../tslint.json",
+  "rules": {
+    "class-name": true,
+    "curly": true,
+    "no-consecutive-blank-lines": true,
+    "no-shadowed-variable": true,
+    "quotemark": [true, "single"],
+    "align": true,
+    "callable-types": false,
+    "forbidden-types": false,
+    "indent": [true, "spaces"],
+    "interface-name": false,
+    "linebreak-style": [true, "LF"],
+    "no-empty-interface": false,
+    "unified-signatures": false,
+    "variable-name": [true, "check-format"],
+    "void-return": false
+  }
+}

From a5638e1ded48eb21b2f5273001de20411abc889e Mon Sep 17 00:00:00 2001
From: Jan Varwig <jan@varwig.org>
Date: Fri, 27 Jan 2017 17:36:37 +0100
Subject: [PATCH 66/87] [react-datepicker] Fix callback signatures

The signatures for onChange, onBlur, and onFocus were wrong.
---
 react-datepicker/index.d.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/react-datepicker/index.d.ts b/react-datepicker/index.d.ts
index aec8b61b72..3f10ad37ca 100644
--- a/react-datepicker/index.d.ts
+++ b/react-datepicker/index.d.ts
@@ -25,9 +25,9 @@ declare module "react-datepicker" {
         maxDate?: {};
         minDate?: {};
         name?: string;
-        onBlur?(handler: (e: any) => void): any;
-        onChange(handler: (date?: any, e?: any) => void): any;
-        onFocus?(handler: (e: any) => void): any;
+        onBlur?(e: any): void;
+        onChange(date?: any, e?: any): void;
+        onFocus?(e: any): void;
         peekNextMonth?: boolean;
         placeholderText?: string;
         popoverAttachment?: string;

From 7c74f67ef7a3cf3fd10354b30bd1d448f8fad5f1 Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 27 Jan 2017 17:21:50 +0000
Subject: [PATCH 67/87] added router?: InjectedRouter; to RouteComponentProps

see https://github.com/ReactTraining/react-router/blob/master/CHANGES.md#v300-beta1
and https://github.com/ReactTraining/react-router/pull/3729
---
 react-router/lib/Router.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/react-router/lib/Router.d.ts b/react-router/lib/Router.d.ts
index a7dff58369..ccfc22979a 100644
--- a/react-router/lib/Router.d.ts
+++ b/react-router/lib/Router.d.ts
@@ -87,6 +87,7 @@ declare namespace Router {
         params?: P;
         route?: PlainRoute;
         routeParams?: R;
+        router?: InjectedRouter;
         routes?: PlainRoute[];
         children?: React.ReactElement<any>;
     }

From 93b63ea6e9ed80dfc7b84a561bce5b6afdf59e5f Mon Sep 17 00:00:00 2001
From: John Reilly <johnny_reilly@hotmail.com>
Date: Fri, 27 Jan 2017 17:24:51 +0000
Subject: [PATCH 68/87] Update to react-router 3.0.0

---
 react-router/index.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/react-router/index.d.ts b/react-router/index.d.ts
index b1a577c617..4e265ce99f 100644
--- a/react-router/index.d.ts
+++ b/react-router/index.d.ts
@@ -1,6 +1,6 @@
-// Type definitions for react-router 2.0
+// Type definitions for react-router 3.0
 // Project: https://github.com/rackt/react-router
-// Definitions by: Sergey Buturlakin <https://github.com/sergey-buturlakin>, Yuichi Murata <https://github.com/mrk21>, Václav Ostrožlík <https://github.com/vasek17>, Nathan Brown <https://github.com/ngbrown>, Alex Wendland <https://github.com/awendland>, Kostya Esmukov <https://github.com/KostyaEsmukov>
+// Definitions by: Sergey Buturlakin <https://github.com/sergey-buturlakin>, Yuichi Murata <https://github.com/mrk21>, Václav Ostrožlík <https://github.com/vasek17>, Nathan Brown <https://github.com/ngbrown>, Alex Wendland <https://github.com/awendland>, Kostya Esmukov <https://github.com/KostyaEsmukov>, John Reilly <https://github.com/johnnyreilly>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.1
 

From 2461ee114f7718677d6c369061e6ad946f517de2 Mon Sep 17 00:00:00 2001
From: Lukas Zech <lukas-zech-software@users.noreply.github.com>
Date: Fri, 27 Jan 2017 18:29:09 +0100
Subject: [PATCH 69/87] Use PartialObject for object predicates in _.every,
 _.find and _.some  (#13994)

* Use PartialObject for object predicates

* Add typescript version

* Update lodash module generator and update modules to TypeScript 2.1

* Use Partial to define PartialObject, fix LodashStatic.find

* Use PartialObject as predicate in lodash.filter

* Add TS2.1 header to bookshelf, lodash-decorators, lodash-es, sequelize/v3, sequelize, sequelize-fixtures, and umzug
---
 bookshelf/index.d.ts                |   1 +
 lodash-decorators/index.d.ts        |   1 +
 lodash-es/index.d.ts                |   1 +
 lodash.add/index.d.ts               |   1 +
 lodash.after/index.d.ts             |   1 +
 lodash.ary/index.d.ts               |   1 +
 lodash.assign/index.d.ts            |   1 +
 lodash.assignin/index.d.ts          |   1 +
 lodash.assigninwith/index.d.ts      |   1 +
 lodash.assignwith/index.d.ts        |   1 +
 lodash.at/index.d.ts                |   1 +
 lodash.attempt/index.d.ts           |   1 +
 lodash.before/index.d.ts            |   1 +
 lodash.bind/index.d.ts              |   1 +
 lodash.bindall/index.d.ts           |   1 +
 lodash.bindkey/index.d.ts           |   1 +
 lodash.camelcase/index.d.ts         |   1 +
 lodash.capitalize/index.d.ts        |   1 +
 lodash.castarray/index.d.ts         |   1 +
 lodash.ceil/index.d.ts              |   1 +
 lodash.chunk/index.d.ts             |   1 +
 lodash.clamp/index.d.ts             |   1 +
 lodash.clone/index.d.ts             |   1 +
 lodash.clonedeep/index.d.ts         |   1 +
 lodash.clonedeepwith/index.d.ts     |   1 +
 lodash.clonewith/index.d.ts         |   1 +
 lodash.compact/index.d.ts           |   1 +
 lodash.concat/index.d.ts            |   1 +
 lodash.constant/index.d.ts          |   1 +
 lodash.countby/index.d.ts           |   1 +
 lodash.create/index.d.ts            |   1 +
 lodash.curry/index.d.ts             |   1 +
 lodash.curryright/index.d.ts        |   1 +
 lodash.debounce/index.d.ts          |   1 +
 lodash.deburr/index.d.ts            |   1 +
 lodash.defaults/index.d.ts          |   1 +
 lodash.defaultsdeep/index.d.ts      |   1 +
 lodash.defer/index.d.ts             |   1 +
 lodash.delay/index.d.ts             |   1 +
 lodash.difference/index.d.ts        |   1 +
 lodash.differenceby/index.d.ts      |   1 +
 lodash.differencewith/index.d.ts    |   1 +
 lodash.drop/index.d.ts              |   1 +
 lodash.dropright/index.d.ts         |   1 +
 lodash.droprightwhile/index.d.ts    |   1 +
 lodash.dropwhile/index.d.ts         |   1 +
 lodash.endswith/index.d.ts          |   1 +
 lodash.eq/index.d.ts                |   1 +
 lodash.escape/index.d.ts            |   1 +
 lodash.escaperegexp/index.d.ts      |   1 +
 lodash.every/index.d.ts             |   1 +
 lodash.fill/index.d.ts              |   1 +
 lodash.filter/index.d.ts            |   1 +
 lodash.find/index.d.ts              |   1 +
 lodash.findindex/index.d.ts         |   1 +
 lodash.findkey/index.d.ts           |   1 +
 lodash.findlast/index.d.ts          |   1 +
 lodash.findlastindex/index.d.ts     |   1 +
 lodash.findlastkey/index.d.ts       |   1 +
 lodash.first/index.d.ts             |   1 +
 lodash.flatmap/index.d.ts           |   1 +
 lodash.flatten/index.d.ts           |   1 +
 lodash.flattendeep/index.d.ts       |   1 +
 lodash.flattendepth/index.d.ts      |   1 +
 lodash.flip/index.d.ts              |   1 +
 lodash.floor/index.d.ts             |   1 +
 lodash.flow/index.d.ts              |   1 +
 lodash.flowright/index.d.ts         |   1 +
 lodash.foreach/index.d.ts           |   1 +
 lodash.foreachright/index.d.ts      |   1 +
 lodash.forin/index.d.ts             |   1 +
 lodash.forinright/index.d.ts        |   1 +
 lodash.forown/index.d.ts            |   1 +
 lodash.forownright/index.d.ts       |   1 +
 lodash.frompairs/index.d.ts         |   1 +
 lodash.functions/index.d.ts         |   1 +
 lodash.functionsin/index.d.ts       |   1 +
 lodash.get/index.d.ts               |   1 +
 lodash.groupby/index.d.ts           |   1 +
 lodash.gt/index.d.ts                |   1 +
 lodash.gte/index.d.ts               |   1 +
 lodash.has/index.d.ts               |   1 +
 lodash.hasin/index.d.ts             |   1 +
 lodash.head/index.d.ts              |   1 +
 lodash.identity/index.d.ts          |   1 +
 lodash.includes/index.d.ts          |   1 +
 lodash.indexof/index.d.ts           |   1 +
 lodash.initial/index.d.ts           |   1 +
 lodash.inrange/index.d.ts           |   1 +
 lodash.intersection/index.d.ts      |   1 +
 lodash.intersectionby/index.d.ts    |   1 +
 lodash.intersectionwith/index.d.ts  |   1 +
 lodash.invert/index.d.ts            |   1 +
 lodash.invertby/index.d.ts          |   1 +
 lodash.invoke/index.d.ts            |   1 +
 lodash.invokemap/index.d.ts         |   1 +
 lodash.isarguments/index.d.ts       |   1 +
 lodash.isarray/index.d.ts           |   1 +
 lodash.isarraybuffer/index.d.ts     |   1 +
 lodash.isarraylike/index.d.ts       |   1 +
 lodash.isarraylikeobject/index.d.ts |   1 +
 lodash.isboolean/index.d.ts         |   1 +
 lodash.isbuffer/index.d.ts          |   1 +
 lodash.isdate/index.d.ts            |   1 +
 lodash.iselement/index.d.ts         |   1 +
 lodash.isempty/index.d.ts           |   1 +
 lodash.isequal/index.d.ts           |   3 +-
 lodash.isequalwith/index.d.ts       |   1 +
 lodash.iserror/index.d.ts           |   1 +
 lodash.isfinite/index.d.ts          |   1 +
 lodash.isfunction/index.d.ts        |   1 +
 lodash.isinteger/index.d.ts         |   1 +
 lodash.islength/index.d.ts          |   1 +
 lodash.ismap/index.d.ts             |   1 +
 lodash.ismatch/index.d.ts           |   1 +
 lodash.ismatchwith/index.d.ts       |   1 +
 lodash.isnan/index.d.ts             |   1 +
 lodash.isnative/index.d.ts          |   1 +
 lodash.isnil/index.d.ts             |   1 +
 lodash.isnull/index.d.ts            |   1 +
 lodash.isnumber/index.d.ts          |   1 +
 lodash.isobject/index.d.ts          |   1 +
 lodash.isobjectlike/index.d.ts      |   1 +
 lodash.isplainobject/index.d.ts     |   1 +
 lodash.isregexp/index.d.ts          |   1 +
 lodash.issafeinteger/index.d.ts     |   1 +
 lodash.isset/index.d.ts             |   1 +
 lodash.isstring/index.d.ts          |   1 +
 lodash.issymbol/index.d.ts          |   1 +
 lodash.istypedarray/index.d.ts      |   1 +
 lodash.isundefined/index.d.ts       |   1 +
 lodash.isweakmap/index.d.ts         |   1 +
 lodash.isweakset/index.d.ts         |   1 +
 lodash.iteratee/index.d.ts          |   1 +
 lodash.join/index.d.ts              |   1 +
 lodash.kebabcase/index.d.ts         |   1 +
 lodash.keyby/index.d.ts             |   1 +
 lodash.keys/index.d.ts              |   1 +
 lodash.keysin/index.d.ts            |   1 +
 lodash.last/index.d.ts              |   1 +
 lodash.lastindexof/index.d.ts       |   1 +
 lodash.lowercase/index.d.ts         |   1 +
 lodash.lowerfirst/index.d.ts        |   1 +
 lodash.lt/index.d.ts                |   1 +
 lodash.lte/index.d.ts               |   1 +
 lodash.mapkeys/index.d.ts           |   1 +
 lodash.mapvalues/index.d.ts         |   1 +
 lodash.matches/index.d.ts           |   1 +
 lodash.matchesproperty/index.d.ts   |   1 +
 lodash.max/index.d.ts               |   1 +
 lodash.maxby/index.d.ts             |   1 +
 lodash.mean/index.d.ts              |   1 +
 lodash.meanby/index.d.ts            |   8 ++
 lodash.meanby/tsconfig.json         |  19 +++++
 lodash.meanby/tslint.json           |   3 +
 lodash.memoize/index.d.ts           |   1 +
 lodash.merge/index.d.ts             |   1 +
 lodash.mergewith/index.d.ts         |   1 +
 lodash.method/index.d.ts            |   1 +
 lodash.methodof/index.d.ts          |   1 +
 lodash.min/index.d.ts               |   1 +
 lodash.minby/index.d.ts             |   1 +
 lodash.mixin/index.d.ts             |   1 +
 lodash.negate/index.d.ts            |   1 +
 lodash.noop/index.d.ts              |   1 +
 lodash.now/index.d.ts               |   1 +
 lodash.ntharg/index.d.ts            |   1 +
 lodash.omit/index.d.ts              |   1 +
 lodash.omitby/index.d.ts            |   1 +
 lodash.once/index.d.ts              |   1 +
 lodash.orderby/index.d.ts           |   1 +
 lodash.over/index.d.ts              |   1 +
 lodash.overargs/index.d.ts          |   1 +
 lodash.overevery/index.d.ts         |   1 +
 lodash.oversome/index.d.ts          |   1 +
 lodash.pad/index.d.ts               |   1 +
 lodash.padend/index.d.ts            |   1 +
 lodash.padstart/index.d.ts          |   1 +
 lodash.parseint/index.d.ts          |   1 +
 lodash.partial/index.d.ts           |   1 +
 lodash.partialright/index.d.ts      |   1 +
 lodash.partition/index.d.ts         |   1 +
 lodash.pick/index.d.ts              |   1 +
 lodash.pickby/index.d.ts            |   1 +
 lodash.property/index.d.ts          |   1 +
 lodash.propertyof/index.d.ts        |   1 +
 lodash.pull/index.d.ts              |   1 +
 lodash.pullall/index.d.ts           |   1 +
 lodash.pullallby/index.d.ts         |   1 +
 lodash.pullat/index.d.ts            |   1 +
 lodash.random/index.d.ts            |   1 +
 lodash.range/index.d.ts             |   1 +
 lodash.rangeright/index.d.ts        |   1 +
 lodash.rearg/index.d.ts             |   1 +
 lodash.reduce/index.d.ts            |   1 +
 lodash.reduceright/index.d.ts       |   1 +
 lodash.reject/index.d.ts            |   1 +
 lodash.remove/index.d.ts            |   1 +
 lodash.repeat/index.d.ts            |   1 +
 lodash.replace/index.d.ts           |   1 +
 lodash.rest/index.d.ts              |   1 +
 lodash.result/index.d.ts            |   1 +
 lodash.reverse/index.d.ts           |   1 +
 lodash.round/index.d.ts             |   1 +
 lodash.sample/index.d.ts            |   1 +
 lodash.samplesize/index.d.ts        |   1 +
 lodash.set/index.d.ts               |   1 +
 lodash.setwith/index.d.ts           |   1 +
 lodash.shuffle/index.d.ts           |   1 +
 lodash.size/index.d.ts              |   1 +
 lodash.slice/index.d.ts             |   1 +
 lodash.snakecase/index.d.ts         |   1 +
 lodash.some/index.d.ts              |   1 +
 lodash.sortby/index.d.ts            |   1 +
 lodash.sortedindex/index.d.ts       |   1 +
 lodash.sortedindexby/index.d.ts     |   1 +
 lodash.sortedindexof/index.d.ts     |   1 +
 lodash.sortedlastindex/index.d.ts   |   1 +
 lodash.sortedlastindexby/index.d.ts |   1 +
 lodash.sortedlastindexof/index.d.ts |   1 +
 lodash.sorteduniq/index.d.ts        |   1 +
 lodash.sorteduniqby/index.d.ts      |   1 +
 lodash.split/index.d.ts             |   1 +
 lodash.spread/index.d.ts            |   1 +
 lodash.startcase/index.d.ts         |   1 +
 lodash.startswith/index.d.ts        |   1 +
 lodash.subtract/index.d.ts          |   1 +
 lodash.sum/index.d.ts               |   1 +
 lodash.sumby/index.d.ts             |   1 +
 lodash.tail/index.d.ts              |   1 +
 lodash.take/index.d.ts              |   1 +
 lodash.takeright/index.d.ts         |   1 +
 lodash.takerightwhile/index.d.ts    |   1 +
 lodash.takewhile/index.d.ts         |   1 +
 lodash.template/index.d.ts          |   1 +
 lodash.throttle/index.d.ts          |   1 +
 lodash.times/index.d.ts             |   1 +
 lodash.toarray/index.d.ts           |   1 +
 lodash.tointeger/index.d.ts         |   1 +
 lodash.tolength/index.d.ts          |   1 +
 lodash.tolower/index.d.ts           |   1 +
 lodash.tonumber/index.d.ts          |   1 +
 lodash.topairs/index.d.ts           |   1 +
 lodash.topairsin/index.d.ts         |   1 +
 lodash.topath/index.d.ts            |   1 +
 lodash.toplainobject/index.d.ts     |   1 +
 lodash.tosafeinteger/index.d.ts     |   1 +
 lodash.tostring/index.d.ts          |   1 +
 lodash.toupper/index.d.ts           |   1 +
 lodash.transform/index.d.ts         |   1 +
 lodash.trim/index.d.ts              |   1 +
 lodash.trimend/index.d.ts           |   1 +
 lodash.trimstart/index.d.ts         |   1 +
 lodash.truncate/index.d.ts          |   1 +
 lodash.unary/index.d.ts             |   1 +
 lodash.unescape/index.d.ts          |   1 +
 lodash.union/index.d.ts             |   1 +
 lodash.unionby/index.d.ts           |   1 +
 lodash.unionwith/index.d.ts         |   1 +
 lodash.uniq/index.d.ts              |   1 +
 lodash.uniqby/index.d.ts            |   1 +
 lodash.uniqueid/index.d.ts          |   1 +
 lodash.uniqwith/index.d.ts          |   1 +
 lodash.unset/index.d.ts             |   1 +
 lodash.unzip/index.d.ts             |   1 +
 lodash.unzipwith/index.d.ts         |   1 +
 lodash.update/index.d.ts            |   1 +
 lodash.uppercase/index.d.ts         |   1 +
 lodash.upperfirst/index.d.ts        |   1 +
 lodash.values/index.d.ts            |   1 +
 lodash.valuesin/index.d.ts          |   1 +
 lodash.without/index.d.ts           |   1 +
 lodash.words/index.d.ts             |   1 +
 lodash.wrap/index.d.ts              |   1 +
 lodash.xor/index.d.ts               |   1 +
 lodash.xorby/index.d.ts             |   1 +
 lodash.xorwith/index.d.ts           |   1 +
 lodash.zip/index.d.ts               |   1 +
 lodash.zipobject/index.d.ts         |   1 +
 lodash.zipwith/index.d.ts           |   1 +
 lodash/index.d.ts                   |  74 +++++++++--------
 lodash/lodash-tests.ts              |  92 ++++++++++-----------
 lodash/meanBy/index.d.ts            |   5 +-
 lodash/scripts/generate-modules.ts  | 119 ++++++++++++++++++++++++++--
 lodash/scripts/tsconfig.json        |  10 +++
 sequelize-fixtures/index.d.ts       |   1 +
 sequelize/index.d.ts                |   1 +
 sequelize/v3/index.d.ts             |   1 +
 umzug/index.d.ts                    |   1 +
 289 files changed, 522 insertions(+), 91 deletions(-)
 create mode 100644 lodash.meanby/index.d.ts
 create mode 100644 lodash.meanby/tsconfig.json
 create mode 100644 lodash.meanby/tslint.json
 create mode 100644 lodash/scripts/tsconfig.json

diff --git a/bookshelf/index.d.ts b/bookshelf/index.d.ts
index 3895ef95a1..56472a3213 100644
--- a/bookshelf/index.d.ts
+++ b/bookshelf/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://bookshelfjs.org/
 // Definitions by: Andrew Schurman <http://github.com/arcticwaters>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import Knex = require('knex');
 import knex = require('knex');
diff --git a/lodash-decorators/index.d.ts b/lodash-decorators/index.d.ts
index 0e0b8d9e3c..eb05886150 100644
--- a/lodash-decorators/index.d.ts
+++ b/lodash-decorators/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/steelsojka/lodash-decorators
 // Definitions by: Qubo <https://github.com/tkqubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /// <reference types="lodash" />
 
diff --git a/lodash-es/index.d.ts b/lodash-es/index.d.ts
index 71f98587ff..1c9e42c18e 100644
--- a/lodash-es/index.d.ts
+++ b/lodash-es/index.d.ts
@@ -2,3 +2,4 @@
 // Project: http://lodash.com/
 // Definitions by: Stephen Lautier <https://github.com/stephenlautier>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
\ No newline at end of file
diff --git a/lodash.add/index.d.ts b/lodash.add/index.d.ts
index 0a9aecd185..76c74086e3 100644
--- a/lodash.add/index.d.ts
+++ b/lodash.add/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { add } from "lodash";
 export = add;
diff --git a/lodash.after/index.d.ts b/lodash.after/index.d.ts
index 52f5efd8e1..7ba8e38a1a 100644
--- a/lodash.after/index.d.ts
+++ b/lodash.after/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { after } from "lodash";
 export = after;
diff --git a/lodash.ary/index.d.ts b/lodash.ary/index.d.ts
index d78cd0c60e..fe902df0d0 100644
--- a/lodash.ary/index.d.ts
+++ b/lodash.ary/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { ary } from "lodash";
 export = ary;
diff --git a/lodash.assign/index.d.ts b/lodash.assign/index.d.ts
index 0558933c3f..8da5d220bf 100644
--- a/lodash.assign/index.d.ts
+++ b/lodash.assign/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { assign } from "lodash";
 export = assign;
diff --git a/lodash.assignin/index.d.ts b/lodash.assignin/index.d.ts
index 7e8740aea3..50551ff9d7 100644
--- a/lodash.assignin/index.d.ts
+++ b/lodash.assignin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { assignIn } from "lodash";
 export = assignIn;
diff --git a/lodash.assigninwith/index.d.ts b/lodash.assigninwith/index.d.ts
index 1e1e3189c1..76f3d2dede 100644
--- a/lodash.assigninwith/index.d.ts
+++ b/lodash.assigninwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { assignInWith } from "lodash";
 export = assignInWith;
diff --git a/lodash.assignwith/index.d.ts b/lodash.assignwith/index.d.ts
index 02e395824d..a01c36eb29 100644
--- a/lodash.assignwith/index.d.ts
+++ b/lodash.assignwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { assignWith } from "lodash";
 export = assignWith;
diff --git a/lodash.at/index.d.ts b/lodash.at/index.d.ts
index 7b237c170b..061d6040b8 100644
--- a/lodash.at/index.d.ts
+++ b/lodash.at/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { at } from "lodash";
 export = at;
diff --git a/lodash.attempt/index.d.ts b/lodash.attempt/index.d.ts
index a93d1efb06..52874b4372 100644
--- a/lodash.attempt/index.d.ts
+++ b/lodash.attempt/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { attempt } from "lodash";
 export = attempt;
diff --git a/lodash.before/index.d.ts b/lodash.before/index.d.ts
index 50456ca93b..3c211206c0 100644
--- a/lodash.before/index.d.ts
+++ b/lodash.before/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { before } from "lodash";
 export = before;
diff --git a/lodash.bind/index.d.ts b/lodash.bind/index.d.ts
index 2ace06a403..eda3868cae 100644
--- a/lodash.bind/index.d.ts
+++ b/lodash.bind/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { bind } from "lodash";
 export = bind;
diff --git a/lodash.bindall/index.d.ts b/lodash.bindall/index.d.ts
index 7d5b08e79e..9a80f928cc 100644
--- a/lodash.bindall/index.d.ts
+++ b/lodash.bindall/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { bindAll } from "lodash";
 export = bindAll;
diff --git a/lodash.bindkey/index.d.ts b/lodash.bindkey/index.d.ts
index 581f950cc1..a7ecab5dd1 100644
--- a/lodash.bindkey/index.d.ts
+++ b/lodash.bindkey/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { bindKey } from "lodash";
 export = bindKey;
diff --git a/lodash.camelcase/index.d.ts b/lodash.camelcase/index.d.ts
index 7e330178df..b489f3f7a5 100644
--- a/lodash.camelcase/index.d.ts
+++ b/lodash.camelcase/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { camelCase } from "lodash";
 export = camelCase;
diff --git a/lodash.capitalize/index.d.ts b/lodash.capitalize/index.d.ts
index 5cdfce9f64..06a3f72fd4 100644
--- a/lodash.capitalize/index.d.ts
+++ b/lodash.capitalize/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { capitalize } from "lodash";
 export = capitalize;
diff --git a/lodash.castarray/index.d.ts b/lodash.castarray/index.d.ts
index 468ae08464..2d77145a0c 100644
--- a/lodash.castarray/index.d.ts
+++ b/lodash.castarray/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { castArray } from "lodash";
 export = castArray;
diff --git a/lodash.ceil/index.d.ts b/lodash.ceil/index.d.ts
index 382e7c6452..4d91e60e65 100644
--- a/lodash.ceil/index.d.ts
+++ b/lodash.ceil/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { ceil } from "lodash";
 export = ceil;
diff --git a/lodash.chunk/index.d.ts b/lodash.chunk/index.d.ts
index 9fd9a55c59..ffd11b71b2 100644
--- a/lodash.chunk/index.d.ts
+++ b/lodash.chunk/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { chunk } from "lodash";
 export = chunk;
diff --git a/lodash.clamp/index.d.ts b/lodash.clamp/index.d.ts
index 58372494cd..0a28f04829 100644
--- a/lodash.clamp/index.d.ts
+++ b/lodash.clamp/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { clamp } from "lodash";
 export = clamp;
diff --git a/lodash.clone/index.d.ts b/lodash.clone/index.d.ts
index b9fa987104..a2d6e34490 100644
--- a/lodash.clone/index.d.ts
+++ b/lodash.clone/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { clone } from "lodash";
 export = clone;
diff --git a/lodash.clonedeep/index.d.ts b/lodash.clonedeep/index.d.ts
index 4bd178bff0..5e9382e296 100644
--- a/lodash.clonedeep/index.d.ts
+++ b/lodash.clonedeep/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { cloneDeep } from "lodash";
 export = cloneDeep;
diff --git a/lodash.clonedeepwith/index.d.ts b/lodash.clonedeepwith/index.d.ts
index e014c80686..80439cef54 100644
--- a/lodash.clonedeepwith/index.d.ts
+++ b/lodash.clonedeepwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { cloneDeepWith } from "lodash";
 export = cloneDeepWith;
diff --git a/lodash.clonewith/index.d.ts b/lodash.clonewith/index.d.ts
index cb29709538..bdaa109a3a 100644
--- a/lodash.clonewith/index.d.ts
+++ b/lodash.clonewith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { cloneWith } from "lodash";
 export = cloneWith;
diff --git a/lodash.compact/index.d.ts b/lodash.compact/index.d.ts
index d6dc0b2fb8..9af681aeb4 100644
--- a/lodash.compact/index.d.ts
+++ b/lodash.compact/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { compact } from "lodash";
 export = compact;
diff --git a/lodash.concat/index.d.ts b/lodash.concat/index.d.ts
index dd6f9bb6e2..692dfa5aab 100644
--- a/lodash.concat/index.d.ts
+++ b/lodash.concat/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { concat } from "lodash";
 export = concat;
diff --git a/lodash.constant/index.d.ts b/lodash.constant/index.d.ts
index 92fc209518..1b941af3ad 100644
--- a/lodash.constant/index.d.ts
+++ b/lodash.constant/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { constant } from "lodash";
 export = constant;
diff --git a/lodash.countby/index.d.ts b/lodash.countby/index.d.ts
index a3c6d24d93..03940a5e7d 100644
--- a/lodash.countby/index.d.ts
+++ b/lodash.countby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { countBy } from "lodash";
 export = countBy;
diff --git a/lodash.create/index.d.ts b/lodash.create/index.d.ts
index 5ca15075eb..e9d553be1c 100644
--- a/lodash.create/index.d.ts
+++ b/lodash.create/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { create } from "lodash";
 export = create;
diff --git a/lodash.curry/index.d.ts b/lodash.curry/index.d.ts
index 61f26316fd..a613fce91a 100644
--- a/lodash.curry/index.d.ts
+++ b/lodash.curry/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { curry } from "lodash";
 export = curry;
diff --git a/lodash.curryright/index.d.ts b/lodash.curryright/index.d.ts
index caf7dfcfe3..b16fdd5147 100644
--- a/lodash.curryright/index.d.ts
+++ b/lodash.curryright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { curryRight } from "lodash";
 export = curryRight;
diff --git a/lodash.debounce/index.d.ts b/lodash.debounce/index.d.ts
index 2bef22974b..4e4e3aec55 100644
--- a/lodash.debounce/index.d.ts
+++ b/lodash.debounce/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { debounce } from "lodash";
 export = debounce;
diff --git a/lodash.deburr/index.d.ts b/lodash.deburr/index.d.ts
index 6f92fcbbd4..0caa30be24 100644
--- a/lodash.deburr/index.d.ts
+++ b/lodash.deburr/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { deburr } from "lodash";
 export = deburr;
diff --git a/lodash.defaults/index.d.ts b/lodash.defaults/index.d.ts
index 15c8e57184..6c0bb1b47b 100644
--- a/lodash.defaults/index.d.ts
+++ b/lodash.defaults/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { defaults } from "lodash";
 export = defaults;
diff --git a/lodash.defaultsdeep/index.d.ts b/lodash.defaultsdeep/index.d.ts
index 22cb0667a3..c552b805ff 100644
--- a/lodash.defaultsdeep/index.d.ts
+++ b/lodash.defaultsdeep/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { defaultsDeep } from "lodash";
 export = defaultsDeep;
diff --git a/lodash.defer/index.d.ts b/lodash.defer/index.d.ts
index ad67ed0c82..6c35dd7513 100644
--- a/lodash.defer/index.d.ts
+++ b/lodash.defer/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { defer } from "lodash";
 export = defer;
diff --git a/lodash.delay/index.d.ts b/lodash.delay/index.d.ts
index b65bd46abe..bb4922c81c 100644
--- a/lodash.delay/index.d.ts
+++ b/lodash.delay/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { delay } from "lodash";
 export = delay;
diff --git a/lodash.difference/index.d.ts b/lodash.difference/index.d.ts
index 38aa798be1..7ad8c6c414 100644
--- a/lodash.difference/index.d.ts
+++ b/lodash.difference/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { difference } from "lodash";
 export = difference;
diff --git a/lodash.differenceby/index.d.ts b/lodash.differenceby/index.d.ts
index 2d0c4859f0..50dfcd6a9c 100644
--- a/lodash.differenceby/index.d.ts
+++ b/lodash.differenceby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { differenceBy } from "lodash";
 export = differenceBy;
diff --git a/lodash.differencewith/index.d.ts b/lodash.differencewith/index.d.ts
index fff454ca64..9870768137 100644
--- a/lodash.differencewith/index.d.ts
+++ b/lodash.differencewith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { differenceWith } from "lodash";
 export = differenceWith;
diff --git a/lodash.drop/index.d.ts b/lodash.drop/index.d.ts
index 0605e176ec..f702675717 100644
--- a/lodash.drop/index.d.ts
+++ b/lodash.drop/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { drop } from "lodash";
 export = drop;
diff --git a/lodash.dropright/index.d.ts b/lodash.dropright/index.d.ts
index 1322022901..1385005315 100644
--- a/lodash.dropright/index.d.ts
+++ b/lodash.dropright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { dropRight } from "lodash";
 export = dropRight;
diff --git a/lodash.droprightwhile/index.d.ts b/lodash.droprightwhile/index.d.ts
index b5fd1a75d2..02f5d13ac8 100644
--- a/lodash.droprightwhile/index.d.ts
+++ b/lodash.droprightwhile/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { dropRightWhile } from "lodash";
 export = dropRightWhile;
diff --git a/lodash.dropwhile/index.d.ts b/lodash.dropwhile/index.d.ts
index e24e46bccc..270e0d0189 100644
--- a/lodash.dropwhile/index.d.ts
+++ b/lodash.dropwhile/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { dropWhile } from "lodash";
 export = dropWhile;
diff --git a/lodash.endswith/index.d.ts b/lodash.endswith/index.d.ts
index 191301b21e..3a1c9b314e 100644
--- a/lodash.endswith/index.d.ts
+++ b/lodash.endswith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { endsWith } from "lodash";
 export = endsWith;
diff --git a/lodash.eq/index.d.ts b/lodash.eq/index.d.ts
index 87e927aa6d..8af8729bb4 100644
--- a/lodash.eq/index.d.ts
+++ b/lodash.eq/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { eq } from "lodash";
 export = eq;
diff --git a/lodash.escape/index.d.ts b/lodash.escape/index.d.ts
index 8e72963f22..a74f554830 100644
--- a/lodash.escape/index.d.ts
+++ b/lodash.escape/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { escape } from "lodash";
 export = escape;
diff --git a/lodash.escaperegexp/index.d.ts b/lodash.escaperegexp/index.d.ts
index 19eb0c6807..b80f492f70 100644
--- a/lodash.escaperegexp/index.d.ts
+++ b/lodash.escaperegexp/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { escapeRegExp } from "lodash";
 export = escapeRegExp;
diff --git a/lodash.every/index.d.ts b/lodash.every/index.d.ts
index a7ce29ad7a..84fd71115a 100644
--- a/lodash.every/index.d.ts
+++ b/lodash.every/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { every } from "lodash";
 export = every;
diff --git a/lodash.fill/index.d.ts b/lodash.fill/index.d.ts
index 1c8c619422..c2b785fbe5 100644
--- a/lodash.fill/index.d.ts
+++ b/lodash.fill/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { fill } from "lodash";
 export = fill;
diff --git a/lodash.filter/index.d.ts b/lodash.filter/index.d.ts
index 83dd5a1ddb..4960ebde70 100644
--- a/lodash.filter/index.d.ts
+++ b/lodash.filter/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { filter } from "lodash";
 export = filter;
diff --git a/lodash.find/index.d.ts b/lodash.find/index.d.ts
index eda8769f54..f1d736f0c0 100644
--- a/lodash.find/index.d.ts
+++ b/lodash.find/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { find } from "lodash";
 export = find;
diff --git a/lodash.findindex/index.d.ts b/lodash.findindex/index.d.ts
index bfb5034785..bc2fee9d18 100644
--- a/lodash.findindex/index.d.ts
+++ b/lodash.findindex/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { findIndex } from "lodash";
 export = findIndex;
diff --git a/lodash.findkey/index.d.ts b/lodash.findkey/index.d.ts
index bf5c2a357c..4bca193179 100644
--- a/lodash.findkey/index.d.ts
+++ b/lodash.findkey/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { findKey } from "lodash";
 export = findKey;
diff --git a/lodash.findlast/index.d.ts b/lodash.findlast/index.d.ts
index ad5f1d00f9..7ec89440be 100644
--- a/lodash.findlast/index.d.ts
+++ b/lodash.findlast/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { findLast } from "lodash";
 export = findLast;
diff --git a/lodash.findlastindex/index.d.ts b/lodash.findlastindex/index.d.ts
index 6e771c3842..37c0ba4567 100644
--- a/lodash.findlastindex/index.d.ts
+++ b/lodash.findlastindex/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { findLastIndex } from "lodash";
 export = findLastIndex;
diff --git a/lodash.findlastkey/index.d.ts b/lodash.findlastkey/index.d.ts
index ea09517b83..6e53f08733 100644
--- a/lodash.findlastkey/index.d.ts
+++ b/lodash.findlastkey/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { findLastKey } from "lodash";
 export = findLastKey;
diff --git a/lodash.first/index.d.ts b/lodash.first/index.d.ts
index b1e1b84a54..21b7337178 100644
--- a/lodash.first/index.d.ts
+++ b/lodash.first/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { first } from "lodash";
 export = first;
diff --git a/lodash.flatmap/index.d.ts b/lodash.flatmap/index.d.ts
index 26d291b7bc..075c3eba57 100644
--- a/lodash.flatmap/index.d.ts
+++ b/lodash.flatmap/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flatMap } from "lodash";
 export = flatMap;
diff --git a/lodash.flatten/index.d.ts b/lodash.flatten/index.d.ts
index 4c3d68eb5e..b0247fd668 100644
--- a/lodash.flatten/index.d.ts
+++ b/lodash.flatten/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flatten } from "lodash";
 export = flatten;
diff --git a/lodash.flattendeep/index.d.ts b/lodash.flattendeep/index.d.ts
index 4e6b573eae..b596ff5fad 100644
--- a/lodash.flattendeep/index.d.ts
+++ b/lodash.flattendeep/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flattenDeep } from "lodash";
 export = flattenDeep;
diff --git a/lodash.flattendepth/index.d.ts b/lodash.flattendepth/index.d.ts
index 186641d1bc..d8df8b242b 100644
--- a/lodash.flattendepth/index.d.ts
+++ b/lodash.flattendepth/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flattenDepth } from "lodash";
 export = flattenDepth;
diff --git a/lodash.flip/index.d.ts b/lodash.flip/index.d.ts
index d4a69991ab..a87354fe7d 100644
--- a/lodash.flip/index.d.ts
+++ b/lodash.flip/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flip } from "lodash";
 export = flip;
diff --git a/lodash.floor/index.d.ts b/lodash.floor/index.d.ts
index 7e43e4335b..ca831b6e0f 100644
--- a/lodash.floor/index.d.ts
+++ b/lodash.floor/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { floor } from "lodash";
 export = floor;
diff --git a/lodash.flow/index.d.ts b/lodash.flow/index.d.ts
index 36be0e704f..d2bc98d1ab 100644
--- a/lodash.flow/index.d.ts
+++ b/lodash.flow/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flow } from "lodash";
 export = flow;
diff --git a/lodash.flowright/index.d.ts b/lodash.flowright/index.d.ts
index 95189e5684..e1275db957 100644
--- a/lodash.flowright/index.d.ts
+++ b/lodash.flowright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { flowRight } from "lodash";
 export = flowRight;
diff --git a/lodash.foreach/index.d.ts b/lodash.foreach/index.d.ts
index d2fd5757b4..9aec8eaf2b 100644
--- a/lodash.foreach/index.d.ts
+++ b/lodash.foreach/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { forEach } from "lodash";
 export = forEach;
diff --git a/lodash.foreachright/index.d.ts b/lodash.foreachright/index.d.ts
index cdd20d5fec..147f43d771 100644
--- a/lodash.foreachright/index.d.ts
+++ b/lodash.foreachright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { forEachRight } from "lodash";
 export = forEachRight;
diff --git a/lodash.forin/index.d.ts b/lodash.forin/index.d.ts
index e95e69f8b4..af03a8a4e1 100644
--- a/lodash.forin/index.d.ts
+++ b/lodash.forin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { forIn } from "lodash";
 export = forIn;
diff --git a/lodash.forinright/index.d.ts b/lodash.forinright/index.d.ts
index 160f182cf9..c79a18f746 100644
--- a/lodash.forinright/index.d.ts
+++ b/lodash.forinright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { forInRight } from "lodash";
 export = forInRight;
diff --git a/lodash.forown/index.d.ts b/lodash.forown/index.d.ts
index 20ae037f37..32d2ac758d 100644
--- a/lodash.forown/index.d.ts
+++ b/lodash.forown/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { forOwn } from "lodash";
 export = forOwn;
diff --git a/lodash.forownright/index.d.ts b/lodash.forownright/index.d.ts
index 0736346722..1a2ff70788 100644
--- a/lodash.forownright/index.d.ts
+++ b/lodash.forownright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { forOwnRight } from "lodash";
 export = forOwnRight;
diff --git a/lodash.frompairs/index.d.ts b/lodash.frompairs/index.d.ts
index db158444d5..b74020f99f 100644
--- a/lodash.frompairs/index.d.ts
+++ b/lodash.frompairs/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { fromPairs } from "lodash";
 export = fromPairs;
diff --git a/lodash.functions/index.d.ts b/lodash.functions/index.d.ts
index 03ca7febbb..865f3c0c1e 100644
--- a/lodash.functions/index.d.ts
+++ b/lodash.functions/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { functions } from "lodash";
 export = functions;
diff --git a/lodash.functionsin/index.d.ts b/lodash.functionsin/index.d.ts
index 93168e67a3..5bfc7a5ca2 100644
--- a/lodash.functionsin/index.d.ts
+++ b/lodash.functionsin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { functionsIn } from "lodash";
 export = functionsIn;
diff --git a/lodash.get/index.d.ts b/lodash.get/index.d.ts
index 91e6b74e66..fd7d336a70 100644
--- a/lodash.get/index.d.ts
+++ b/lodash.get/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { get } from "lodash";
 export = get;
diff --git a/lodash.groupby/index.d.ts b/lodash.groupby/index.d.ts
index 06156f9b00..c55d2e3db7 100644
--- a/lodash.groupby/index.d.ts
+++ b/lodash.groupby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { groupBy } from "lodash";
 export = groupBy;
diff --git a/lodash.gt/index.d.ts b/lodash.gt/index.d.ts
index f541f408a8..cd5aa96019 100644
--- a/lodash.gt/index.d.ts
+++ b/lodash.gt/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { gt } from "lodash";
 export = gt;
diff --git a/lodash.gte/index.d.ts b/lodash.gte/index.d.ts
index 4041863b22..0e9eb62a7c 100644
--- a/lodash.gte/index.d.ts
+++ b/lodash.gte/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { gte } from "lodash";
 export = gte;
diff --git a/lodash.has/index.d.ts b/lodash.has/index.d.ts
index aaf4c27353..28ee7cd4e9 100644
--- a/lodash.has/index.d.ts
+++ b/lodash.has/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { has } from "lodash";
 export = has;
diff --git a/lodash.hasin/index.d.ts b/lodash.hasin/index.d.ts
index 53052f5cc3..09be59f7da 100644
--- a/lodash.hasin/index.d.ts
+++ b/lodash.hasin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { hasIn } from "lodash";
 export = hasIn;
diff --git a/lodash.head/index.d.ts b/lodash.head/index.d.ts
index d2e3e06eac..0b3b6da94f 100644
--- a/lodash.head/index.d.ts
+++ b/lodash.head/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { head } from "lodash";
 export = head;
diff --git a/lodash.identity/index.d.ts b/lodash.identity/index.d.ts
index 810313857d..0e683ed1c4 100644
--- a/lodash.identity/index.d.ts
+++ b/lodash.identity/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { identity } from "lodash";
 export = identity;
diff --git a/lodash.includes/index.d.ts b/lodash.includes/index.d.ts
index dccbc5e3ee..ddb703d38d 100644
--- a/lodash.includes/index.d.ts
+++ b/lodash.includes/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { includes } from "lodash";
 export = includes;
diff --git a/lodash.indexof/index.d.ts b/lodash.indexof/index.d.ts
index 0551b9acc6..180fde9e2f 100644
--- a/lodash.indexof/index.d.ts
+++ b/lodash.indexof/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { indexOf } from "lodash";
 export = indexOf;
diff --git a/lodash.initial/index.d.ts b/lodash.initial/index.d.ts
index 303d425de1..40fec082f7 100644
--- a/lodash.initial/index.d.ts
+++ b/lodash.initial/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { initial } from "lodash";
 export = initial;
diff --git a/lodash.inrange/index.d.ts b/lodash.inrange/index.d.ts
index b65ff730db..8140966ac2 100644
--- a/lodash.inrange/index.d.ts
+++ b/lodash.inrange/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { inRange } from "lodash";
 export = inRange;
diff --git a/lodash.intersection/index.d.ts b/lodash.intersection/index.d.ts
index 8bc7dbde4f..149a324277 100644
--- a/lodash.intersection/index.d.ts
+++ b/lodash.intersection/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { intersection } from "lodash";
 export = intersection;
diff --git a/lodash.intersectionby/index.d.ts b/lodash.intersectionby/index.d.ts
index 74ae5d4dfc..81c206df48 100644
--- a/lodash.intersectionby/index.d.ts
+++ b/lodash.intersectionby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { intersectionBy } from "lodash";
 export = intersectionBy;
diff --git a/lodash.intersectionwith/index.d.ts b/lodash.intersectionwith/index.d.ts
index 73b816b192..e18b9d41ff 100644
--- a/lodash.intersectionwith/index.d.ts
+++ b/lodash.intersectionwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { intersectionWith } from "lodash";
 export = intersectionWith;
diff --git a/lodash.invert/index.d.ts b/lodash.invert/index.d.ts
index 99fdb04c76..25fe9ce360 100644
--- a/lodash.invert/index.d.ts
+++ b/lodash.invert/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { invert } from "lodash";
 export = invert;
diff --git a/lodash.invertby/index.d.ts b/lodash.invertby/index.d.ts
index c3959934a2..63e5c70405 100644
--- a/lodash.invertby/index.d.ts
+++ b/lodash.invertby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { invertBy } from "lodash";
 export = invertBy;
diff --git a/lodash.invoke/index.d.ts b/lodash.invoke/index.d.ts
index 7af1475a29..e16b07d462 100644
--- a/lodash.invoke/index.d.ts
+++ b/lodash.invoke/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { invoke } from "lodash";
 export = invoke;
diff --git a/lodash.invokemap/index.d.ts b/lodash.invokemap/index.d.ts
index 4995018391..1365a4f752 100644
--- a/lodash.invokemap/index.d.ts
+++ b/lodash.invokemap/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { invokeMap } from "lodash";
 export = invokeMap;
diff --git a/lodash.isarguments/index.d.ts b/lodash.isarguments/index.d.ts
index f46218acd9..7eb30e26dd 100644
--- a/lodash.isarguments/index.d.ts
+++ b/lodash.isarguments/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isArguments } from "lodash";
 export = isArguments;
diff --git a/lodash.isarray/index.d.ts b/lodash.isarray/index.d.ts
index a777294028..d4df88d8d7 100644
--- a/lodash.isarray/index.d.ts
+++ b/lodash.isarray/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isArray } from "lodash";
 export = isArray;
diff --git a/lodash.isarraybuffer/index.d.ts b/lodash.isarraybuffer/index.d.ts
index 827727c372..bb65311721 100644
--- a/lodash.isarraybuffer/index.d.ts
+++ b/lodash.isarraybuffer/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isArrayBuffer } from "lodash";
 export = isArrayBuffer;
diff --git a/lodash.isarraylike/index.d.ts b/lodash.isarraylike/index.d.ts
index 44e0da10d2..e722669eb4 100644
--- a/lodash.isarraylike/index.d.ts
+++ b/lodash.isarraylike/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isArrayLike } from "lodash";
 export = isArrayLike;
diff --git a/lodash.isarraylikeobject/index.d.ts b/lodash.isarraylikeobject/index.d.ts
index e5a2a5d847..8d094d8261 100644
--- a/lodash.isarraylikeobject/index.d.ts
+++ b/lodash.isarraylikeobject/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isArrayLikeObject } from "lodash";
 export = isArrayLikeObject;
diff --git a/lodash.isboolean/index.d.ts b/lodash.isboolean/index.d.ts
index 39ae1338ee..38bcb53406 100644
--- a/lodash.isboolean/index.d.ts
+++ b/lodash.isboolean/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isBoolean } from "lodash";
 export = isBoolean;
diff --git a/lodash.isbuffer/index.d.ts b/lodash.isbuffer/index.d.ts
index 985ce28952..0c9d922967 100644
--- a/lodash.isbuffer/index.d.ts
+++ b/lodash.isbuffer/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isBuffer } from "lodash";
 export = isBuffer;
diff --git a/lodash.isdate/index.d.ts b/lodash.isdate/index.d.ts
index 0c59a7a05f..bc61921489 100644
--- a/lodash.isdate/index.d.ts
+++ b/lodash.isdate/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isDate } from "lodash";
 export = isDate;
diff --git a/lodash.iselement/index.d.ts b/lodash.iselement/index.d.ts
index d4538e9e40..e059b8b1f5 100644
--- a/lodash.iselement/index.d.ts
+++ b/lodash.iselement/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isElement } from "lodash";
 export = isElement;
diff --git a/lodash.isempty/index.d.ts b/lodash.isempty/index.d.ts
index dc550a45a3..bff4c499aa 100644
--- a/lodash.isempty/index.d.ts
+++ b/lodash.isempty/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isEmpty } from "lodash";
 export = isEmpty;
diff --git a/lodash.isequal/index.d.ts b/lodash.isequal/index.d.ts
index b19d0c04d5..d06f5a2a2a 100644
--- a/lodash.isequal/index.d.ts
+++ b/lodash.isequal/index.d.ts
@@ -1,7 +1,8 @@
-// Type definitions for lodash.isEqual 4.4
+// Type definitions for lodash.isEqual 4.5
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isEqual } from "lodash";
 export = isEqual;
diff --git a/lodash.isequalwith/index.d.ts b/lodash.isequalwith/index.d.ts
index 1298491bd4..250895312b 100644
--- a/lodash.isequalwith/index.d.ts
+++ b/lodash.isequalwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isEqualWith } from "lodash";
 export = isEqualWith;
diff --git a/lodash.iserror/index.d.ts b/lodash.iserror/index.d.ts
index d12d1b7cce..42a2bc0923 100644
--- a/lodash.iserror/index.d.ts
+++ b/lodash.iserror/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isError } from "lodash";
 export = isError;
diff --git a/lodash.isfinite/index.d.ts b/lodash.isfinite/index.d.ts
index 8cd096692c..02a28fa204 100644
--- a/lodash.isfinite/index.d.ts
+++ b/lodash.isfinite/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isFinite } from "lodash";
 export = isFinite;
diff --git a/lodash.isfunction/index.d.ts b/lodash.isfunction/index.d.ts
index a2276e5633..3253939f6b 100644
--- a/lodash.isfunction/index.d.ts
+++ b/lodash.isfunction/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isFunction } from "lodash";
 export = isFunction;
diff --git a/lodash.isinteger/index.d.ts b/lodash.isinteger/index.d.ts
index f2d78c2b1f..7d604a19b6 100644
--- a/lodash.isinteger/index.d.ts
+++ b/lodash.isinteger/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isInteger } from "lodash";
 export = isInteger;
diff --git a/lodash.islength/index.d.ts b/lodash.islength/index.d.ts
index abcc89acda..6ed54652e5 100644
--- a/lodash.islength/index.d.ts
+++ b/lodash.islength/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isLength } from "lodash";
 export = isLength;
diff --git a/lodash.ismap/index.d.ts b/lodash.ismap/index.d.ts
index 62bde83057..1fc93f3462 100644
--- a/lodash.ismap/index.d.ts
+++ b/lodash.ismap/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isMap } from "lodash";
 export = isMap;
diff --git a/lodash.ismatch/index.d.ts b/lodash.ismatch/index.d.ts
index 617f6c9bda..3c8de854e8 100644
--- a/lodash.ismatch/index.d.ts
+++ b/lodash.ismatch/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isMatch } from "lodash";
 export = isMatch;
diff --git a/lodash.ismatchwith/index.d.ts b/lodash.ismatchwith/index.d.ts
index ed8ff1b11b..c69ae83ea6 100644
--- a/lodash.ismatchwith/index.d.ts
+++ b/lodash.ismatchwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isMatchWith } from "lodash";
 export = isMatchWith;
diff --git a/lodash.isnan/index.d.ts b/lodash.isnan/index.d.ts
index 029f8c6e9b..1d95ffe160 100644
--- a/lodash.isnan/index.d.ts
+++ b/lodash.isnan/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isNaN } from "lodash";
 export = isNaN;
diff --git a/lodash.isnative/index.d.ts b/lodash.isnative/index.d.ts
index 133f9cea47..29050811ef 100644
--- a/lodash.isnative/index.d.ts
+++ b/lodash.isnative/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isNative } from "lodash";
 export = isNative;
diff --git a/lodash.isnil/index.d.ts b/lodash.isnil/index.d.ts
index d3aaa388ee..5199f1657a 100644
--- a/lodash.isnil/index.d.ts
+++ b/lodash.isnil/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isNil } from "lodash";
 export = isNil;
diff --git a/lodash.isnull/index.d.ts b/lodash.isnull/index.d.ts
index 87a041d532..117b41f2e5 100644
--- a/lodash.isnull/index.d.ts
+++ b/lodash.isnull/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isNull } from "lodash";
 export = isNull;
diff --git a/lodash.isnumber/index.d.ts b/lodash.isnumber/index.d.ts
index 1f88c13582..70e51e9842 100644
--- a/lodash.isnumber/index.d.ts
+++ b/lodash.isnumber/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isNumber } from "lodash";
 export = isNumber;
diff --git a/lodash.isobject/index.d.ts b/lodash.isobject/index.d.ts
index 229357175a..6f79f888df 100644
--- a/lodash.isobject/index.d.ts
+++ b/lodash.isobject/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isObject } from "lodash";
 export = isObject;
diff --git a/lodash.isobjectlike/index.d.ts b/lodash.isobjectlike/index.d.ts
index 5c5c4bcdb3..8423f18a2a 100644
--- a/lodash.isobjectlike/index.d.ts
+++ b/lodash.isobjectlike/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isObjectLike } from "lodash";
 export = isObjectLike;
diff --git a/lodash.isplainobject/index.d.ts b/lodash.isplainobject/index.d.ts
index c5e4af82cd..33e85453d2 100644
--- a/lodash.isplainobject/index.d.ts
+++ b/lodash.isplainobject/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isPlainObject } from "lodash";
 export = isPlainObject;
diff --git a/lodash.isregexp/index.d.ts b/lodash.isregexp/index.d.ts
index bb6e4c182b..509c93a365 100644
--- a/lodash.isregexp/index.d.ts
+++ b/lodash.isregexp/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isRegExp } from "lodash";
 export = isRegExp;
diff --git a/lodash.issafeinteger/index.d.ts b/lodash.issafeinteger/index.d.ts
index 9c86763ba2..28fe1c868c 100644
--- a/lodash.issafeinteger/index.d.ts
+++ b/lodash.issafeinteger/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isSafeInteger } from "lodash";
 export = isSafeInteger;
diff --git a/lodash.isset/index.d.ts b/lodash.isset/index.d.ts
index eb77cabac8..67f643bb74 100644
--- a/lodash.isset/index.d.ts
+++ b/lodash.isset/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isSet } from "lodash";
 export = isSet;
diff --git a/lodash.isstring/index.d.ts b/lodash.isstring/index.d.ts
index 67ee27673d..42cca91fee 100644
--- a/lodash.isstring/index.d.ts
+++ b/lodash.isstring/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isString } from "lodash";
 export = isString;
diff --git a/lodash.issymbol/index.d.ts b/lodash.issymbol/index.d.ts
index d7be47d922..16468073cc 100644
--- a/lodash.issymbol/index.d.ts
+++ b/lodash.issymbol/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isSymbol } from "lodash";
 export = isSymbol;
diff --git a/lodash.istypedarray/index.d.ts b/lodash.istypedarray/index.d.ts
index 138f4baa08..e93a364295 100644
--- a/lodash.istypedarray/index.d.ts
+++ b/lodash.istypedarray/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isTypedArray } from "lodash";
 export = isTypedArray;
diff --git a/lodash.isundefined/index.d.ts b/lodash.isundefined/index.d.ts
index 2b112959c9..e9a3553600 100644
--- a/lodash.isundefined/index.d.ts
+++ b/lodash.isundefined/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isUndefined } from "lodash";
 export = isUndefined;
diff --git a/lodash.isweakmap/index.d.ts b/lodash.isweakmap/index.d.ts
index a6fbc47986..7e2be4cfb2 100644
--- a/lodash.isweakmap/index.d.ts
+++ b/lodash.isweakmap/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isWeakMap } from "lodash";
 export = isWeakMap;
diff --git a/lodash.isweakset/index.d.ts b/lodash.isweakset/index.d.ts
index d4b016f106..d7e1a801eb 100644
--- a/lodash.isweakset/index.d.ts
+++ b/lodash.isweakset/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { isWeakSet } from "lodash";
 export = isWeakSet;
diff --git a/lodash.iteratee/index.d.ts b/lodash.iteratee/index.d.ts
index 3e494ef2c8..7f6a197f12 100644
--- a/lodash.iteratee/index.d.ts
+++ b/lodash.iteratee/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { iteratee } from "lodash";
 export = iteratee;
diff --git a/lodash.join/index.d.ts b/lodash.join/index.d.ts
index 14f26d67ed..a8dd2622a1 100644
--- a/lodash.join/index.d.ts
+++ b/lodash.join/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { join } from "lodash";
 export = join;
diff --git a/lodash.kebabcase/index.d.ts b/lodash.kebabcase/index.d.ts
index 0851c7672a..00163a5a33 100644
--- a/lodash.kebabcase/index.d.ts
+++ b/lodash.kebabcase/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { kebabCase } from "lodash";
 export = kebabCase;
diff --git a/lodash.keyby/index.d.ts b/lodash.keyby/index.d.ts
index 51aac439ca..8b5700ad76 100644
--- a/lodash.keyby/index.d.ts
+++ b/lodash.keyby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { keyBy } from "lodash";
 export = keyBy;
diff --git a/lodash.keys/index.d.ts b/lodash.keys/index.d.ts
index b514c21483..d862fb0541 100644
--- a/lodash.keys/index.d.ts
+++ b/lodash.keys/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { keys } from "lodash";
 export = keys;
diff --git a/lodash.keysin/index.d.ts b/lodash.keysin/index.d.ts
index 66a18cdfa7..e15bece518 100644
--- a/lodash.keysin/index.d.ts
+++ b/lodash.keysin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { keysIn } from "lodash";
 export = keysIn;
diff --git a/lodash.last/index.d.ts b/lodash.last/index.d.ts
index a06a998d86..29b4ce9c63 100644
--- a/lodash.last/index.d.ts
+++ b/lodash.last/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { last } from "lodash";
 export = last;
diff --git a/lodash.lastindexof/index.d.ts b/lodash.lastindexof/index.d.ts
index 5fccab48d0..a9459ada4d 100644
--- a/lodash.lastindexof/index.d.ts
+++ b/lodash.lastindexof/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { lastIndexOf } from "lodash";
 export = lastIndexOf;
diff --git a/lodash.lowercase/index.d.ts b/lodash.lowercase/index.d.ts
index 4232be29ad..b9505737bc 100644
--- a/lodash.lowercase/index.d.ts
+++ b/lodash.lowercase/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { lowerCase } from "lodash";
 export = lowerCase;
diff --git a/lodash.lowerfirst/index.d.ts b/lodash.lowerfirst/index.d.ts
index c5d0ea1ca6..424d02631b 100644
--- a/lodash.lowerfirst/index.d.ts
+++ b/lodash.lowerfirst/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { lowerFirst } from "lodash";
 export = lowerFirst;
diff --git a/lodash.lt/index.d.ts b/lodash.lt/index.d.ts
index 71cc6c1c00..5bad744986 100644
--- a/lodash.lt/index.d.ts
+++ b/lodash.lt/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { lt } from "lodash";
 export = lt;
diff --git a/lodash.lte/index.d.ts b/lodash.lte/index.d.ts
index 61ddce98b1..5299138c0f 100644
--- a/lodash.lte/index.d.ts
+++ b/lodash.lte/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { lte } from "lodash";
 export = lte;
diff --git a/lodash.mapkeys/index.d.ts b/lodash.mapkeys/index.d.ts
index c56b7647f5..bb32f2862f 100644
--- a/lodash.mapkeys/index.d.ts
+++ b/lodash.mapkeys/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { mapKeys } from "lodash";
 export = mapKeys;
diff --git a/lodash.mapvalues/index.d.ts b/lodash.mapvalues/index.d.ts
index 4507f9234e..db516f2de8 100644
--- a/lodash.mapvalues/index.d.ts
+++ b/lodash.mapvalues/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { mapValues } from "lodash";
 export = mapValues;
diff --git a/lodash.matches/index.d.ts b/lodash.matches/index.d.ts
index 9179ed074b..f80ba05944 100644
--- a/lodash.matches/index.d.ts
+++ b/lodash.matches/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { matches } from "lodash";
 export = matches;
diff --git a/lodash.matchesproperty/index.d.ts b/lodash.matchesproperty/index.d.ts
index afbb8dbfb3..e240a6ebad 100644
--- a/lodash.matchesproperty/index.d.ts
+++ b/lodash.matchesproperty/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { matchesProperty } from "lodash";
 export = matchesProperty;
diff --git a/lodash.max/index.d.ts b/lodash.max/index.d.ts
index 55167fee93..dc8297841f 100644
--- a/lodash.max/index.d.ts
+++ b/lodash.max/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { max } from "lodash";
 export = max;
diff --git a/lodash.maxby/index.d.ts b/lodash.maxby/index.d.ts
index 2513ce999f..47210f79a7 100644
--- a/lodash.maxby/index.d.ts
+++ b/lodash.maxby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { maxBy } from "lodash";
 export = maxBy;
diff --git a/lodash.mean/index.d.ts b/lodash.mean/index.d.ts
index bbf8183e23..dc839ace51 100644
--- a/lodash.mean/index.d.ts
+++ b/lodash.mean/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { mean } from "lodash";
 export = mean;
diff --git a/lodash.meanby/index.d.ts b/lodash.meanby/index.d.ts
new file mode 100644
index 0000000000..8973d40ded
--- /dev/null
+++ b/lodash.meanby/index.d.ts
@@ -0,0 +1,8 @@
+// Type definitions for lodash.meanBy 4.10
+// Project: http://lodash.com/
+// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+import { meanBy } from "lodash";
+export = meanBy;
diff --git a/lodash.meanby/tsconfig.json b/lodash.meanby/tsconfig.json
new file mode 100644
index 0000000000..5692e5627e
--- /dev/null
+++ b/lodash.meanby/tsconfig.json
@@ -0,0 +1,19 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    }
+}
\ No newline at end of file
diff --git a/lodash.meanby/tslint.json b/lodash.meanby/tslint.json
new file mode 100644
index 0000000000..192203ab54
--- /dev/null
+++ b/lodash.meanby/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "../tslint.json"
+}
\ No newline at end of file
diff --git a/lodash.memoize/index.d.ts b/lodash.memoize/index.d.ts
index 6a4c57a197..25002a9086 100644
--- a/lodash.memoize/index.d.ts
+++ b/lodash.memoize/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { memoize } from "lodash";
 export = memoize;
diff --git a/lodash.merge/index.d.ts b/lodash.merge/index.d.ts
index f4250afe0a..a5352b8cc9 100644
--- a/lodash.merge/index.d.ts
+++ b/lodash.merge/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { merge } from "lodash";
 export = merge;
diff --git a/lodash.mergewith/index.d.ts b/lodash.mergewith/index.d.ts
index d22369299e..85cad973d9 100644
--- a/lodash.mergewith/index.d.ts
+++ b/lodash.mergewith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { mergeWith } from "lodash";
 export = mergeWith;
diff --git a/lodash.method/index.d.ts b/lodash.method/index.d.ts
index d890f661e2..cee310ff55 100644
--- a/lodash.method/index.d.ts
+++ b/lodash.method/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { method } from "lodash";
 export = method;
diff --git a/lodash.methodof/index.d.ts b/lodash.methodof/index.d.ts
index b464af2fc4..5420de784a 100644
--- a/lodash.methodof/index.d.ts
+++ b/lodash.methodof/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { methodOf } from "lodash";
 export = methodOf;
diff --git a/lodash.min/index.d.ts b/lodash.min/index.d.ts
index 5f4dc842dd..87fccd9876 100644
--- a/lodash.min/index.d.ts
+++ b/lodash.min/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { min } from "lodash";
 export = min;
diff --git a/lodash.minby/index.d.ts b/lodash.minby/index.d.ts
index 95293a83bf..d46f507c70 100644
--- a/lodash.minby/index.d.ts
+++ b/lodash.minby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { minBy } from "lodash";
 export = minBy;
diff --git a/lodash.mixin/index.d.ts b/lodash.mixin/index.d.ts
index 78190227b1..8a4190762b 100644
--- a/lodash.mixin/index.d.ts
+++ b/lodash.mixin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { mixin } from "lodash";
 export = mixin;
diff --git a/lodash.negate/index.d.ts b/lodash.negate/index.d.ts
index 48796a3750..a4c8b4b88e 100644
--- a/lodash.negate/index.d.ts
+++ b/lodash.negate/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { negate } from "lodash";
 export = negate;
diff --git a/lodash.noop/index.d.ts b/lodash.noop/index.d.ts
index 632d3d1292..04e6cacbb3 100644
--- a/lodash.noop/index.d.ts
+++ b/lodash.noop/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { noop } from "lodash";
 export = noop;
diff --git a/lodash.now/index.d.ts b/lodash.now/index.d.ts
index 80e893d018..ecda7f778d 100644
--- a/lodash.now/index.d.ts
+++ b/lodash.now/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { now } from "lodash";
 export = now;
diff --git a/lodash.ntharg/index.d.ts b/lodash.ntharg/index.d.ts
index 51eb387c96..0d35cb5772 100644
--- a/lodash.ntharg/index.d.ts
+++ b/lodash.ntharg/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { nthArg } from "lodash";
 export = nthArg;
diff --git a/lodash.omit/index.d.ts b/lodash.omit/index.d.ts
index b60f1d503b..491b505016 100644
--- a/lodash.omit/index.d.ts
+++ b/lodash.omit/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { omit } from "lodash";
 export = omit;
diff --git a/lodash.omitby/index.d.ts b/lodash.omitby/index.d.ts
index 82c8b6d063..fee479036b 100644
--- a/lodash.omitby/index.d.ts
+++ b/lodash.omitby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { omitBy } from "lodash";
 export = omitBy;
diff --git a/lodash.once/index.d.ts b/lodash.once/index.d.ts
index 3089544fe9..3f8622e6a0 100644
--- a/lodash.once/index.d.ts
+++ b/lodash.once/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { once } from "lodash";
 export = once;
diff --git a/lodash.orderby/index.d.ts b/lodash.orderby/index.d.ts
index e862a62e96..b348cefebc 100644
--- a/lodash.orderby/index.d.ts
+++ b/lodash.orderby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { orderBy } from "lodash";
 export = orderBy;
diff --git a/lodash.over/index.d.ts b/lodash.over/index.d.ts
index 1df6138a41..5715f0a46e 100644
--- a/lodash.over/index.d.ts
+++ b/lodash.over/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { over } from "lodash";
 export = over;
diff --git a/lodash.overargs/index.d.ts b/lodash.overargs/index.d.ts
index 1cd9c19126..576ab8588a 100644
--- a/lodash.overargs/index.d.ts
+++ b/lodash.overargs/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { overArgs } from "lodash";
 export = overArgs;
diff --git a/lodash.overevery/index.d.ts b/lodash.overevery/index.d.ts
index 2211dc569b..68d6cd3639 100644
--- a/lodash.overevery/index.d.ts
+++ b/lodash.overevery/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { overEvery } from "lodash";
 export = overEvery;
diff --git a/lodash.oversome/index.d.ts b/lodash.oversome/index.d.ts
index f8ec5329f6..4e4fe4eb5c 100644
--- a/lodash.oversome/index.d.ts
+++ b/lodash.oversome/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { overSome } from "lodash";
 export = overSome;
diff --git a/lodash.pad/index.d.ts b/lodash.pad/index.d.ts
index 06a7c7f5ac..259c312381 100644
--- a/lodash.pad/index.d.ts
+++ b/lodash.pad/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pad } from "lodash";
 export = pad;
diff --git a/lodash.padend/index.d.ts b/lodash.padend/index.d.ts
index b42ad0ab11..825479dae8 100644
--- a/lodash.padend/index.d.ts
+++ b/lodash.padend/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { padEnd } from "lodash";
 export = padEnd;
diff --git a/lodash.padstart/index.d.ts b/lodash.padstart/index.d.ts
index b020c51ee5..b3607d61cc 100644
--- a/lodash.padstart/index.d.ts
+++ b/lodash.padstart/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { padStart } from "lodash";
 export = padStart;
diff --git a/lodash.parseint/index.d.ts b/lodash.parseint/index.d.ts
index cafd05c882..4724867112 100644
--- a/lodash.parseint/index.d.ts
+++ b/lodash.parseint/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { parseInt } from "lodash";
 export = parseInt;
diff --git a/lodash.partial/index.d.ts b/lodash.partial/index.d.ts
index 4d6dc3c303..8466a32963 100644
--- a/lodash.partial/index.d.ts
+++ b/lodash.partial/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { partial } from "lodash";
 export = partial;
diff --git a/lodash.partialright/index.d.ts b/lodash.partialright/index.d.ts
index d24675203d..5f9f7bef4d 100644
--- a/lodash.partialright/index.d.ts
+++ b/lodash.partialright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { partialRight } from "lodash";
 export = partialRight;
diff --git a/lodash.partition/index.d.ts b/lodash.partition/index.d.ts
index c79c676a46..d481bae93b 100644
--- a/lodash.partition/index.d.ts
+++ b/lodash.partition/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { partition } from "lodash";
 export = partition;
diff --git a/lodash.pick/index.d.ts b/lodash.pick/index.d.ts
index 7fa2ef6e84..f27646190a 100644
--- a/lodash.pick/index.d.ts
+++ b/lodash.pick/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pick } from "lodash";
 export = pick;
diff --git a/lodash.pickby/index.d.ts b/lodash.pickby/index.d.ts
index 2c72e96edd..0a77aaedc8 100644
--- a/lodash.pickby/index.d.ts
+++ b/lodash.pickby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pickBy } from "lodash";
 export = pickBy;
diff --git a/lodash.property/index.d.ts b/lodash.property/index.d.ts
index e9ea2b894e..90e3eb20b3 100644
--- a/lodash.property/index.d.ts
+++ b/lodash.property/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { property } from "lodash";
 export = property;
diff --git a/lodash.propertyof/index.d.ts b/lodash.propertyof/index.d.ts
index d52d898afa..2db1d2461f 100644
--- a/lodash.propertyof/index.d.ts
+++ b/lodash.propertyof/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { propertyOf } from "lodash";
 export = propertyOf;
diff --git a/lodash.pull/index.d.ts b/lodash.pull/index.d.ts
index b60aec6f73..7232218789 100644
--- a/lodash.pull/index.d.ts
+++ b/lodash.pull/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pull } from "lodash";
 export = pull;
diff --git a/lodash.pullall/index.d.ts b/lodash.pullall/index.d.ts
index 4c55d19fc0..9503a4c6e5 100644
--- a/lodash.pullall/index.d.ts
+++ b/lodash.pullall/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pullAll } from "lodash";
 export = pullAll;
diff --git a/lodash.pullallby/index.d.ts b/lodash.pullallby/index.d.ts
index 18bc32f579..4f5c91696f 100644
--- a/lodash.pullallby/index.d.ts
+++ b/lodash.pullallby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pullAllBy } from "lodash";
 export = pullAllBy;
diff --git a/lodash.pullat/index.d.ts b/lodash.pullat/index.d.ts
index 4a7c29cb90..2330713675 100644
--- a/lodash.pullat/index.d.ts
+++ b/lodash.pullat/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { pullAt } from "lodash";
 export = pullAt;
diff --git a/lodash.random/index.d.ts b/lodash.random/index.d.ts
index 018f4e1c99..87ba37f817 100644
--- a/lodash.random/index.d.ts
+++ b/lodash.random/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { random } from "lodash";
 export = random;
diff --git a/lodash.range/index.d.ts b/lodash.range/index.d.ts
index 289101b98a..6e9871a10a 100644
--- a/lodash.range/index.d.ts
+++ b/lodash.range/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { range } from "lodash";
 export = range;
diff --git a/lodash.rangeright/index.d.ts b/lodash.rangeright/index.d.ts
index 15d7f8be2b..b7fcfd8b34 100644
--- a/lodash.rangeright/index.d.ts
+++ b/lodash.rangeright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { rangeRight } from "lodash";
 export = rangeRight;
diff --git a/lodash.rearg/index.d.ts b/lodash.rearg/index.d.ts
index 987565e162..8c6f912bcd 100644
--- a/lodash.rearg/index.d.ts
+++ b/lodash.rearg/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { rearg } from "lodash";
 export = rearg;
diff --git a/lodash.reduce/index.d.ts b/lodash.reduce/index.d.ts
index 44f4007e94..5ef634a93d 100644
--- a/lodash.reduce/index.d.ts
+++ b/lodash.reduce/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { reduce } from "lodash";
 export = reduce;
diff --git a/lodash.reduceright/index.d.ts b/lodash.reduceright/index.d.ts
index 3377523e1a..ee3e05ea62 100644
--- a/lodash.reduceright/index.d.ts
+++ b/lodash.reduceright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { reduceRight } from "lodash";
 export = reduceRight;
diff --git a/lodash.reject/index.d.ts b/lodash.reject/index.d.ts
index f7e56a60bc..2a7a953403 100644
--- a/lodash.reject/index.d.ts
+++ b/lodash.reject/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { reject } from "lodash";
 export = reject;
diff --git a/lodash.remove/index.d.ts b/lodash.remove/index.d.ts
index b6b2871f51..cf3ecdb008 100644
--- a/lodash.remove/index.d.ts
+++ b/lodash.remove/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { remove } from "lodash";
 export = remove;
diff --git a/lodash.repeat/index.d.ts b/lodash.repeat/index.d.ts
index a0ab5e77f2..066a9f7741 100644
--- a/lodash.repeat/index.d.ts
+++ b/lodash.repeat/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { repeat } from "lodash";
 export = repeat;
diff --git a/lodash.replace/index.d.ts b/lodash.replace/index.d.ts
index d1dc58bad0..deaf6f5925 100644
--- a/lodash.replace/index.d.ts
+++ b/lodash.replace/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { replace } from "lodash";
 export = replace;
diff --git a/lodash.rest/index.d.ts b/lodash.rest/index.d.ts
index c8b2728ec5..12d89f07a4 100644
--- a/lodash.rest/index.d.ts
+++ b/lodash.rest/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { rest } from "lodash";
 export = rest;
diff --git a/lodash.result/index.d.ts b/lodash.result/index.d.ts
index 344d75766a..ca67b40446 100644
--- a/lodash.result/index.d.ts
+++ b/lodash.result/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { result } from "lodash";
 export = result;
diff --git a/lodash.reverse/index.d.ts b/lodash.reverse/index.d.ts
index 8da6b703f7..0486ee3715 100644
--- a/lodash.reverse/index.d.ts
+++ b/lodash.reverse/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { reverse } from "lodash";
 export = reverse;
diff --git a/lodash.round/index.d.ts b/lodash.round/index.d.ts
index 828aee5487..5eb7dddb09 100644
--- a/lodash.round/index.d.ts
+++ b/lodash.round/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { round } from "lodash";
 export = round;
diff --git a/lodash.sample/index.d.ts b/lodash.sample/index.d.ts
index 2fa651cce8..b5873086e2 100644
--- a/lodash.sample/index.d.ts
+++ b/lodash.sample/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sample } from "lodash";
 export = sample;
diff --git a/lodash.samplesize/index.d.ts b/lodash.samplesize/index.d.ts
index 5be09b8960..01a187726b 100644
--- a/lodash.samplesize/index.d.ts
+++ b/lodash.samplesize/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sampleSize } from "lodash";
 export = sampleSize;
diff --git a/lodash.set/index.d.ts b/lodash.set/index.d.ts
index 45c51f879a..f76b88790e 100644
--- a/lodash.set/index.d.ts
+++ b/lodash.set/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { set } from "lodash";
 export = set;
diff --git a/lodash.setwith/index.d.ts b/lodash.setwith/index.d.ts
index 8c41eb3be6..43502688be 100644
--- a/lodash.setwith/index.d.ts
+++ b/lodash.setwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { setWith } from "lodash";
 export = setWith;
diff --git a/lodash.shuffle/index.d.ts b/lodash.shuffle/index.d.ts
index 7b8e65fde0..1283f11844 100644
--- a/lodash.shuffle/index.d.ts
+++ b/lodash.shuffle/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { shuffle } from "lodash";
 export = shuffle;
diff --git a/lodash.size/index.d.ts b/lodash.size/index.d.ts
index 6e7201c394..e0aa69d12f 100644
--- a/lodash.size/index.d.ts
+++ b/lodash.size/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { size } from "lodash";
 export = size;
diff --git a/lodash.slice/index.d.ts b/lodash.slice/index.d.ts
index b9206644eb..2b53bb2386 100644
--- a/lodash.slice/index.d.ts
+++ b/lodash.slice/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { slice } from "lodash";
 export = slice;
diff --git a/lodash.snakecase/index.d.ts b/lodash.snakecase/index.d.ts
index 36fbaec580..db2758999b 100644
--- a/lodash.snakecase/index.d.ts
+++ b/lodash.snakecase/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { snakeCase } from "lodash";
 export = snakeCase;
diff --git a/lodash.some/index.d.ts b/lodash.some/index.d.ts
index e722a5ccae..3de45fa161 100644
--- a/lodash.some/index.d.ts
+++ b/lodash.some/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { some } from "lodash";
 export = some;
diff --git a/lodash.sortby/index.d.ts b/lodash.sortby/index.d.ts
index 028b50fa20..cc75aa6dca 100644
--- a/lodash.sortby/index.d.ts
+++ b/lodash.sortby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortBy } from "lodash";
 export = sortBy;
diff --git a/lodash.sortedindex/index.d.ts b/lodash.sortedindex/index.d.ts
index 9c799fec11..ab6e8eca1f 100644
--- a/lodash.sortedindex/index.d.ts
+++ b/lodash.sortedindex/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedIndex } from "lodash";
 export = sortedIndex;
diff --git a/lodash.sortedindexby/index.d.ts b/lodash.sortedindexby/index.d.ts
index 73601c7b4d..1f5d0c15ac 100644
--- a/lodash.sortedindexby/index.d.ts
+++ b/lodash.sortedindexby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedIndexBy } from "lodash";
 export = sortedIndexBy;
diff --git a/lodash.sortedindexof/index.d.ts b/lodash.sortedindexof/index.d.ts
index 471e408bb9..814afd3e3c 100644
--- a/lodash.sortedindexof/index.d.ts
+++ b/lodash.sortedindexof/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedIndexOf } from "lodash";
 export = sortedIndexOf;
diff --git a/lodash.sortedlastindex/index.d.ts b/lodash.sortedlastindex/index.d.ts
index 95825a983a..5a1c0faa7d 100644
--- a/lodash.sortedlastindex/index.d.ts
+++ b/lodash.sortedlastindex/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedLastIndex } from "lodash";
 export = sortedLastIndex;
diff --git a/lodash.sortedlastindexby/index.d.ts b/lodash.sortedlastindexby/index.d.ts
index e5a167a17b..5b939599b2 100644
--- a/lodash.sortedlastindexby/index.d.ts
+++ b/lodash.sortedlastindexby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedLastIndexBy } from "lodash";
 export = sortedLastIndexBy;
diff --git a/lodash.sortedlastindexof/index.d.ts b/lodash.sortedlastindexof/index.d.ts
index c908ede67a..9817ef54f5 100644
--- a/lodash.sortedlastindexof/index.d.ts
+++ b/lodash.sortedlastindexof/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedLastIndexOf } from "lodash";
 export = sortedLastIndexOf;
diff --git a/lodash.sorteduniq/index.d.ts b/lodash.sorteduniq/index.d.ts
index c9ff4eb4e7..c8b8feea6f 100644
--- a/lodash.sorteduniq/index.d.ts
+++ b/lodash.sorteduniq/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedUniq } from "lodash";
 export = sortedUniq;
diff --git a/lodash.sorteduniqby/index.d.ts b/lodash.sorteduniqby/index.d.ts
index 295d3bcaf3..637895af43 100644
--- a/lodash.sorteduniqby/index.d.ts
+++ b/lodash.sorteduniqby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sortedUniqBy } from "lodash";
 export = sortedUniqBy;
diff --git a/lodash.split/index.d.ts b/lodash.split/index.d.ts
index 43c187c455..fd5a261917 100644
--- a/lodash.split/index.d.ts
+++ b/lodash.split/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { split } from "lodash";
 export = split;
diff --git a/lodash.spread/index.d.ts b/lodash.spread/index.d.ts
index adaec68385..7bbc4e9245 100644
--- a/lodash.spread/index.d.ts
+++ b/lodash.spread/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { spread } from "lodash";
 export = spread;
diff --git a/lodash.startcase/index.d.ts b/lodash.startcase/index.d.ts
index 9c550e4a0c..53798256bc 100644
--- a/lodash.startcase/index.d.ts
+++ b/lodash.startcase/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { startCase } from "lodash";
 export = startCase;
diff --git a/lodash.startswith/index.d.ts b/lodash.startswith/index.d.ts
index ebb4178ac5..84071e3d10 100644
--- a/lodash.startswith/index.d.ts
+++ b/lodash.startswith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { startsWith } from "lodash";
 export = startsWith;
diff --git a/lodash.subtract/index.d.ts b/lodash.subtract/index.d.ts
index 6d148eb796..0b57101cee 100644
--- a/lodash.subtract/index.d.ts
+++ b/lodash.subtract/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { subtract } from "lodash";
 export = subtract;
diff --git a/lodash.sum/index.d.ts b/lodash.sum/index.d.ts
index df4194246e..e6aaf24aee 100644
--- a/lodash.sum/index.d.ts
+++ b/lodash.sum/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sum } from "lodash";
 export = sum;
diff --git a/lodash.sumby/index.d.ts b/lodash.sumby/index.d.ts
index dad7e3dfa7..e1f21e1454 100644
--- a/lodash.sumby/index.d.ts
+++ b/lodash.sumby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { sumBy } from "lodash";
 export = sumBy;
diff --git a/lodash.tail/index.d.ts b/lodash.tail/index.d.ts
index 1edf5423c0..7543f1ae31 100644
--- a/lodash.tail/index.d.ts
+++ b/lodash.tail/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { tail } from "lodash";
 export = tail;
diff --git a/lodash.take/index.d.ts b/lodash.take/index.d.ts
index f477178ee3..688eaf7b8d 100644
--- a/lodash.take/index.d.ts
+++ b/lodash.take/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { take } from "lodash";
 export = take;
diff --git a/lodash.takeright/index.d.ts b/lodash.takeright/index.d.ts
index f44b5b7a99..9599696c72 100644
--- a/lodash.takeright/index.d.ts
+++ b/lodash.takeright/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { takeRight } from "lodash";
 export = takeRight;
diff --git a/lodash.takerightwhile/index.d.ts b/lodash.takerightwhile/index.d.ts
index 1940bdab6a..b0ccc8647f 100644
--- a/lodash.takerightwhile/index.d.ts
+++ b/lodash.takerightwhile/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { takeRightWhile } from "lodash";
 export = takeRightWhile;
diff --git a/lodash.takewhile/index.d.ts b/lodash.takewhile/index.d.ts
index b1c7464e21..8e557afdd4 100644
--- a/lodash.takewhile/index.d.ts
+++ b/lodash.takewhile/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { takeWhile } from "lodash";
 export = takeWhile;
diff --git a/lodash.template/index.d.ts b/lodash.template/index.d.ts
index af31692e84..a81b832990 100644
--- a/lodash.template/index.d.ts
+++ b/lodash.template/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { template } from "lodash";
 export = template;
diff --git a/lodash.throttle/index.d.ts b/lodash.throttle/index.d.ts
index ed74ec008b..0a2903b317 100644
--- a/lodash.throttle/index.d.ts
+++ b/lodash.throttle/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { throttle } from "lodash";
 export = throttle;
diff --git a/lodash.times/index.d.ts b/lodash.times/index.d.ts
index adabd498e2..f899aac24e 100644
--- a/lodash.times/index.d.ts
+++ b/lodash.times/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { times } from "lodash";
 export = times;
diff --git a/lodash.toarray/index.d.ts b/lodash.toarray/index.d.ts
index 42e878de35..f1cb6ecdea 100644
--- a/lodash.toarray/index.d.ts
+++ b/lodash.toarray/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toArray } from "lodash";
 export = toArray;
diff --git a/lodash.tointeger/index.d.ts b/lodash.tointeger/index.d.ts
index 19a97ef2fd..32f5bafbb7 100644
--- a/lodash.tointeger/index.d.ts
+++ b/lodash.tointeger/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toInteger } from "lodash";
 export = toInteger;
diff --git a/lodash.tolength/index.d.ts b/lodash.tolength/index.d.ts
index 1170461e93..0af29d75fd 100644
--- a/lodash.tolength/index.d.ts
+++ b/lodash.tolength/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toLength } from "lodash";
 export = toLength;
diff --git a/lodash.tolower/index.d.ts b/lodash.tolower/index.d.ts
index 1f350ff005..1403cc4cee 100644
--- a/lodash.tolower/index.d.ts
+++ b/lodash.tolower/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toLower } from "lodash";
 export = toLower;
diff --git a/lodash.tonumber/index.d.ts b/lodash.tonumber/index.d.ts
index fd6fe57a0b..aeacc96956 100644
--- a/lodash.tonumber/index.d.ts
+++ b/lodash.tonumber/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toNumber } from "lodash";
 export = toNumber;
diff --git a/lodash.topairs/index.d.ts b/lodash.topairs/index.d.ts
index 0623631aac..e5c92897ba 100644
--- a/lodash.topairs/index.d.ts
+++ b/lodash.topairs/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toPairs } from "lodash";
 export = toPairs;
diff --git a/lodash.topairsin/index.d.ts b/lodash.topairsin/index.d.ts
index 6da8aac997..c4980bf227 100644
--- a/lodash.topairsin/index.d.ts
+++ b/lodash.topairsin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toPairsIn } from "lodash";
 export = toPairsIn;
diff --git a/lodash.topath/index.d.ts b/lodash.topath/index.d.ts
index ed9ce7c5a9..5647cbca88 100644
--- a/lodash.topath/index.d.ts
+++ b/lodash.topath/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toPath } from "lodash";
 export = toPath;
diff --git a/lodash.toplainobject/index.d.ts b/lodash.toplainobject/index.d.ts
index c1b5793d7d..27de1990bd 100644
--- a/lodash.toplainobject/index.d.ts
+++ b/lodash.toplainobject/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toPlainObject } from "lodash";
 export = toPlainObject;
diff --git a/lodash.tosafeinteger/index.d.ts b/lodash.tosafeinteger/index.d.ts
index b126b0188a..c8d7567a70 100644
--- a/lodash.tosafeinteger/index.d.ts
+++ b/lodash.tosafeinteger/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toSafeInteger } from "lodash";
 export = toSafeInteger;
diff --git a/lodash.tostring/index.d.ts b/lodash.tostring/index.d.ts
index bf9ed55be9..42f59393f1 100644
--- a/lodash.tostring/index.d.ts
+++ b/lodash.tostring/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toString } from "lodash";
 export = toString;
diff --git a/lodash.toupper/index.d.ts b/lodash.toupper/index.d.ts
index 9e26f50c2b..02bef92ae3 100644
--- a/lodash.toupper/index.d.ts
+++ b/lodash.toupper/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { toUpper } from "lodash";
 export = toUpper;
diff --git a/lodash.transform/index.d.ts b/lodash.transform/index.d.ts
index 78c4bfdb7c..ac5ee501cf 100644
--- a/lodash.transform/index.d.ts
+++ b/lodash.transform/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { transform } from "lodash";
 export = transform;
diff --git a/lodash.trim/index.d.ts b/lodash.trim/index.d.ts
index 4848a6ddbd..7aa6fcc4e6 100644
--- a/lodash.trim/index.d.ts
+++ b/lodash.trim/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { trim } from "lodash";
 export = trim;
diff --git a/lodash.trimend/index.d.ts b/lodash.trimend/index.d.ts
index 116f295b06..1e871b2126 100644
--- a/lodash.trimend/index.d.ts
+++ b/lodash.trimend/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { trimEnd } from "lodash";
 export = trimEnd;
diff --git a/lodash.trimstart/index.d.ts b/lodash.trimstart/index.d.ts
index 93df2c2483..c525bf5c8e 100644
--- a/lodash.trimstart/index.d.ts
+++ b/lodash.trimstart/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { trimStart } from "lodash";
 export = trimStart;
diff --git a/lodash.truncate/index.d.ts b/lodash.truncate/index.d.ts
index b658478894..cb421e8a26 100644
--- a/lodash.truncate/index.d.ts
+++ b/lodash.truncate/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { truncate } from "lodash";
 export = truncate;
diff --git a/lodash.unary/index.d.ts b/lodash.unary/index.d.ts
index 55c5e46f1d..12a281f507 100644
--- a/lodash.unary/index.d.ts
+++ b/lodash.unary/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unary } from "lodash";
 export = unary;
diff --git a/lodash.unescape/index.d.ts b/lodash.unescape/index.d.ts
index c78fecec34..8340900768 100644
--- a/lodash.unescape/index.d.ts
+++ b/lodash.unescape/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unescape } from "lodash";
 export = unescape;
diff --git a/lodash.union/index.d.ts b/lodash.union/index.d.ts
index 386967dec1..cddbaf12aa 100644
--- a/lodash.union/index.d.ts
+++ b/lodash.union/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { union } from "lodash";
 export = union;
diff --git a/lodash.unionby/index.d.ts b/lodash.unionby/index.d.ts
index dc0c0f1245..9c64ce9ed8 100644
--- a/lodash.unionby/index.d.ts
+++ b/lodash.unionby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unionBy } from "lodash";
 export = unionBy;
diff --git a/lodash.unionwith/index.d.ts b/lodash.unionwith/index.d.ts
index da2cae278a..a3757085ba 100644
--- a/lodash.unionwith/index.d.ts
+++ b/lodash.unionwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unionWith } from "lodash";
 export = unionWith;
diff --git a/lodash.uniq/index.d.ts b/lodash.uniq/index.d.ts
index 675b710028..a274db1b67 100644
--- a/lodash.uniq/index.d.ts
+++ b/lodash.uniq/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { uniq } from "lodash";
 export = uniq;
diff --git a/lodash.uniqby/index.d.ts b/lodash.uniqby/index.d.ts
index 0eedfb6d3f..c6dcd7c0c1 100644
--- a/lodash.uniqby/index.d.ts
+++ b/lodash.uniqby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { uniqBy } from "lodash";
 export = uniqBy;
diff --git a/lodash.uniqueid/index.d.ts b/lodash.uniqueid/index.d.ts
index abd2ebf55c..046d62d775 100644
--- a/lodash.uniqueid/index.d.ts
+++ b/lodash.uniqueid/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { uniqueId } from "lodash";
 export = uniqueId;
diff --git a/lodash.uniqwith/index.d.ts b/lodash.uniqwith/index.d.ts
index 6541b4ef03..515bcc2cba 100644
--- a/lodash.uniqwith/index.d.ts
+++ b/lodash.uniqwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { uniqWith } from "lodash";
 export = uniqWith;
diff --git a/lodash.unset/index.d.ts b/lodash.unset/index.d.ts
index dcf8e6881a..7662c3fd56 100644
--- a/lodash.unset/index.d.ts
+++ b/lodash.unset/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unset } from "lodash";
 export = unset;
diff --git a/lodash.unzip/index.d.ts b/lodash.unzip/index.d.ts
index 6fe3ebc759..60adfd32e9 100644
--- a/lodash.unzip/index.d.ts
+++ b/lodash.unzip/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unzip } from "lodash";
 export = unzip;
diff --git a/lodash.unzipwith/index.d.ts b/lodash.unzipwith/index.d.ts
index 64f86e45e7..641d1c1468 100644
--- a/lodash.unzipwith/index.d.ts
+++ b/lodash.unzipwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { unzipWith } from "lodash";
 export = unzipWith;
diff --git a/lodash.update/index.d.ts b/lodash.update/index.d.ts
index 27c5499aeb..f861786fd0 100644
--- a/lodash.update/index.d.ts
+++ b/lodash.update/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { update } from "lodash";
 export = update;
diff --git a/lodash.uppercase/index.d.ts b/lodash.uppercase/index.d.ts
index 82e3f7af39..152bf80399 100644
--- a/lodash.uppercase/index.d.ts
+++ b/lodash.uppercase/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { upperCase } from "lodash";
 export = upperCase;
diff --git a/lodash.upperfirst/index.d.ts b/lodash.upperfirst/index.d.ts
index 27cfc0bdc2..b76d75f8b6 100644
--- a/lodash.upperfirst/index.d.ts
+++ b/lodash.upperfirst/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { upperFirst } from "lodash";
 export = upperFirst;
diff --git a/lodash.values/index.d.ts b/lodash.values/index.d.ts
index 633dbed76d..ff22e7ef36 100644
--- a/lodash.values/index.d.ts
+++ b/lodash.values/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { values } from "lodash";
 export = values;
diff --git a/lodash.valuesin/index.d.ts b/lodash.valuesin/index.d.ts
index 1cca8a411d..9137156620 100644
--- a/lodash.valuesin/index.d.ts
+++ b/lodash.valuesin/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { valuesIn } from "lodash";
 export = valuesIn;
diff --git a/lodash.without/index.d.ts b/lodash.without/index.d.ts
index 41a55ad642..88cea94b79 100644
--- a/lodash.without/index.d.ts
+++ b/lodash.without/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { without } from "lodash";
 export = without;
diff --git a/lodash.words/index.d.ts b/lodash.words/index.d.ts
index 6b886a190f..8076cee94f 100644
--- a/lodash.words/index.d.ts
+++ b/lodash.words/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { words } from "lodash";
 export = words;
diff --git a/lodash.wrap/index.d.ts b/lodash.wrap/index.d.ts
index 18ee43f769..ef1e41cb4c 100644
--- a/lodash.wrap/index.d.ts
+++ b/lodash.wrap/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { wrap } from "lodash";
 export = wrap;
diff --git a/lodash.xor/index.d.ts b/lodash.xor/index.d.ts
index 6a641cd153..819ad96d72 100644
--- a/lodash.xor/index.d.ts
+++ b/lodash.xor/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { xor } from "lodash";
 export = xor;
diff --git a/lodash.xorby/index.d.ts b/lodash.xorby/index.d.ts
index 49ef941467..a60b78d049 100644
--- a/lodash.xorby/index.d.ts
+++ b/lodash.xorby/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { xorBy } from "lodash";
 export = xorBy;
diff --git a/lodash.xorwith/index.d.ts b/lodash.xorwith/index.d.ts
index 30b53691f9..ccf6499b89 100644
--- a/lodash.xorwith/index.d.ts
+++ b/lodash.xorwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { xorWith } from "lodash";
 export = xorWith;
diff --git a/lodash.zip/index.d.ts b/lodash.zip/index.d.ts
index f4793f82ae..278d7a7cff 100644
--- a/lodash.zip/index.d.ts
+++ b/lodash.zip/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { zip } from "lodash";
 export = zip;
diff --git a/lodash.zipobject/index.d.ts b/lodash.zipobject/index.d.ts
index df8d4929f9..63e4661ff6 100644
--- a/lodash.zipobject/index.d.ts
+++ b/lodash.zipobject/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { zipObject } from "lodash";
 export = zipObject;
diff --git a/lodash.zipwith/index.d.ts b/lodash.zipwith/index.d.ts
index e5b4a6714a..93c417ca57 100644
--- a/lodash.zipwith/index.d.ts
+++ b/lodash.zipwith/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 import { zipWith } from "lodash";
 export = zipWith;
diff --git a/lodash/index.d.ts b/lodash/index.d.ts
index 678e0c58b9..0cda5ae3d5 100644
--- a/lodash/index.d.ts
+++ b/lodash/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://lodash.com/
 // Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /**
 ### 4.0.0 Changelog (https://github.com/lodash/lodash/wiki/Changelog)
@@ -241,7 +242,10 @@ export as namespace _;
 
 declare var _: _.LoDashStatic;
 
+type PartialObject<T> = Partial<T>;
+
 declare namespace _ {
+
     type Many<T> = T | T[];
 
     interface LoDashStatic {
@@ -6558,9 +6562,9 @@ declare namespace _ {
         /**
          * @see _.every
          */
-        every<TObject extends {}, T>(
+        every<T>(
             collection: List<T>|Dictionary<T>|NumericDictionary<T>,
-            predicate?: TObject
+            predicate?: PartialObject<T>
         ): boolean;
     }
 
@@ -6582,8 +6586,8 @@ declare namespace _ {
         /**
          * @see _.every
          */
-        every<TObject extends {}>(
-            predicate?: TObject
+        every(
+            predicate?: PartialObject<T>
         ): boolean;
     }
 
@@ -6605,8 +6609,8 @@ declare namespace _ {
         /**
          * @see _.every
          */
-        every<TObject extends {}>(
-            predicate?: TObject
+        every<TResult>(
+            predicate?: PartialObject<TResult>
         ): boolean;
     }
 
@@ -6628,8 +6632,8 @@ declare namespace _ {
         /**
          * @see _.every
          */
-        every<TObject extends {}>(
-            predicate?: TObject
+        every(
+            predicate?: PartialObject<T>
         ): LoDashExplicitWrapper<boolean>;
     }
 
@@ -6651,8 +6655,8 @@ declare namespace _ {
         /**
          * @see _.every
          */
-        every<TObject extends {}>(
-            predicate?: TObject
+        every<TResult>(
+            predicate?: PartialObject<TResult>
         ): LoDashExplicitWrapper<boolean>;
     }
 
@@ -6708,9 +6712,9 @@ declare namespace _ {
         /**
          * @see _.filter
          */
-        filter<W extends {}, T>(
+        filter<T>(
             collection: List<T>|Dictionary<T>,
-            predicate: W
+            predicate: PartialObject<T>
         ): T[];
     }
 
@@ -6741,7 +6745,7 @@ declare namespace _ {
         /**
          * @see _.filter
          */
-        filter<W>(predicate: W): LoDashImplicitArrayWrapper<T>;
+        filter(predicate: PartialObject<T>): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitObjectWrapper<T> {
@@ -6762,7 +6766,7 @@ declare namespace _ {
         /**
          * @see _.filter
          */
-        filter<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>;
+        filter<T>(predicate: PartialObject<T>): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitWrapper<T> {
@@ -6792,7 +6796,7 @@ declare namespace _ {
         /**
          * @see _.filter
          */
-        filter<W>(predicate: W): LoDashExplicitArrayWrapper<T>;
+        filter(predicate: PartialObject<T>): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
@@ -6813,7 +6817,7 @@ declare namespace _ {
         /**
          * @see _.filter
          */
-        filter<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>;
+        filter<T>(predicate: PartialObject<T>): LoDashExplicitArrayWrapper<T>;
     }
 
     //_.find
@@ -6863,9 +6867,9 @@ declare namespace _ {
         /**
          * @see _.find
          */
-        find<TObject extends {}, T>(
+        find<T>(
             collection: List<T>|Dictionary<T>,
-            predicate?: TObject,
+            predicate?: PartialObject<T>,
             fromIndex?: number
         ): T|undefined;
     }
@@ -6890,8 +6894,8 @@ declare namespace _ {
         /**
          * @see _.find
          */
-        find<TObject extends {}>(
-            predicate?: TObject,
+        find(
+            predicate?: PartialObject<T>,
             fromIndex?: number
         ): T|undefined;
     }
@@ -6916,8 +6920,8 @@ declare namespace _ {
         /**
          * @see _.find
          */
-        find<TObject extends {}, TResult>(
-            predicate?: TObject,
+        find<TResult>(
+            predicate?: PartialObject<TResult>,
             fromIndex?: number
         ): TResult|undefined;
     }
@@ -9204,9 +9208,9 @@ declare namespace _ {
         /**
          * @see _.some
          */
-        some<TObject extends {}, T>(
+        some<T>(
             collection: List<T>|Dictionary<T>|NumericDictionary<T>,
-            predicate?: TObject
+            predicate?: PartialObject<T>
         ): boolean;
 
         /**
@@ -9214,15 +9218,15 @@ declare namespace _ {
          */
         some<T>(
             collection: List<T>|Dictionary<T>|NumericDictionary<T>,
-            predicate?: Object
+            predicate?: PartialObject<T>
         ): boolean;
 
         /**
          * @see _.some
          */
-        some<TObject extends {}>(
+        some<T>(
             collection: Object,
-            predicate?: TObject
+            predicate?: PartialObject<T>
         ): boolean;
     }
 
@@ -9244,8 +9248,8 @@ declare namespace _ {
         /**
          * @see _.some
          */
-        some<TObject extends {}>(
-            predicate?: TObject
+        some(
+            predicate?: PartialObject<T>
         ): boolean;
     }
 
@@ -9267,8 +9271,8 @@ declare namespace _ {
         /**
          * @see _.some
          */
-        some<TObject extends {}>(
-            predicate?: TObject
+        some<TResult>(
+            predicate?: PartialObject<TResult>
         ): boolean;
     }
 
@@ -9290,8 +9294,8 @@ declare namespace _ {
         /**
          * @see _.some
          */
-        some<TObject extends {}>(
-            predicate?: TObject
+        some(
+            predicate?: PartialObject<T>
         ): LoDashExplicitWrapper<boolean>;
     }
 
@@ -9313,8 +9317,8 @@ declare namespace _ {
         /**
          * @see _.some
          */
-        some<TObject extends {}>(
-            predicate?: TObject
+        some<TResult>(
+            predicate?: PartialObject<TResult>
         ): LoDashExplicitWrapper<boolean>;
     }
 
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index c1a5ca3e64..7268f1a8c2 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -3530,49 +3530,49 @@ namespace TestEvery {
         result = _.every<SampleObject>(array, listIterator);
         result = _.every<SampleObject>(array, 'a');
         result = _.every<SampleObject>(array, ['a', 42]);
-        result = _.every<{a: number}, SampleObject>(array, {a: 42});
+        result = _.every<SampleObject>(array, {a: 42});
 
         result = _.every<SampleObject>(list);
         result = _.every<SampleObject>(list, listIterator);
         result = _.every<SampleObject>(list, 'a');
         result = _.every<SampleObject>(list, ['a', 42]);
-        result = _.every<{a: number}, SampleObject>(list, {a: 42});
+        result = _.every<SampleObject>(list, {a: 42});
 
         result = _.every<SampleObject>(dictionary);
         result = _.every<SampleObject>(dictionary, dictionaryIterator);
         result = _.every<SampleObject>(dictionary, 'a');
         result = _.every<SampleObject>(dictionary, ['a', 42]);
-        result = _.every<{a: number}, SampleObject>(dictionary, {a: 42});
+        result = _.every<SampleObject>(dictionary, {a: 42});
 
         result = _.every<SampleObject>(numericDictionary);
         result = _.every<SampleObject>(numericDictionary, numericDictionaryIterator);
         result = _.every<SampleObject>(numericDictionary, 'a');
         result = _.every<SampleObject>(numericDictionary, ['a', 42]);
-        result = _.every<{a: number}, SampleObject>(numericDictionary, {a: 42});
+        result = _.every<SampleObject>(numericDictionary, {a: 42});
 
         result = _(array).every();
         result = _(array).every(listIterator);
         result = _(array).every('a');
         result = _(array).every(['a', 42]);
-        result = _(array).every<{a: number}>({a: 42});
+        result = _(array).every({a: 42});
 
         result = _(list).every<SampleObject>();
         result = _(list).every<SampleObject>(listIterator);
         result = _(list).every('a');
         result = _(list).every(['a', 42]);
-        result = _(list).every<{a: number}>({a: 42});
+        result = _(list).every({a: 42});
 
         result = _(dictionary).every<SampleObject>();
         result = _(dictionary).every<SampleObject>(dictionaryIterator);
         result = _(dictionary).every('a');
         result = _(dictionary).every(['a', 42]);
-        result = _(dictionary).every<{a: number}>({a: 42});
+        result = _(dictionary).every({a: 42});
 
         result = _(numericDictionary).every<SampleObject>();
         result = _(numericDictionary).every<SampleObject>(numericDictionaryIterator);
         result = _(numericDictionary).every('a');
         result = _(numericDictionary).every(['a', 42]);
-        result = _(numericDictionary).every<{a: number}>({a: 42});
+        result = _(numericDictionary).every({a: 42});
     }
 
     {
@@ -3582,19 +3582,19 @@ namespace TestEvery {
         result = _(array).chain().every(listIterator);
         result = _(array).chain().every('a');
         result = _(array).chain().every(['a', 42]);
-        result = _(array).chain().every<{a: number}>({a: 42});
+        result = _(array).chain().every({a: 42});
 
         result = _(list).chain().every<SampleObject>();
         result = _(list).chain().every<SampleObject>(listIterator);
         result = _(list).chain().every('a');
         result = _(list).chain().every(['a', 42]);
-        result = _(list).chain().every<{a: number}>({a: 42});
+        result = _(list).chain().every<SampleObject>({a: 42});
 
         result = _(dictionary).chain().every<SampleObject>();
         result = _(dictionary).chain().every<SampleObject>(dictionaryIterator);
         result = _(dictionary).chain().every('a');
         result = _(dictionary).chain().every(['a', 42]);
-        result = _(dictionary).chain().every<{a: number}>({a: 42});
+        result = _(dictionary).chain().every<SampleObject>({a: 42});
 
         result = _(numericDictionary).chain().every<SampleObject>();
         result = _(numericDictionary).chain().every<SampleObject>(numericDictionaryIterator);
@@ -3625,15 +3625,15 @@ namespace TestFilter {
 
         result = _.filter<TResult>(array, listIterator);
         result = _.filter<TResult>(array, '');
-        result = _.filter<{a: number}, TResult>(array, {a: 42});
+        result = _.filter<TResult>(array, {a: 42});
 
         result = _.filter<TResult>(list, listIterator);
         result = _.filter<TResult>(list, '');
-        result = _.filter<{a: number}, TResult>(list, {a: 42});
+        result = _.filter<TResult>(list, {a: 42});
 
         result = _.filter<TResult>(dictionary, dictionaryIterator);
         result = _.filter<TResult>(dictionary, '');
-        result = _.filter<{a: number}, TResult>(dictionary, {a: 42});
+        result = _.filter<TResult>(dictionary, {a: 42});
     }
 
     {
@@ -3647,15 +3647,15 @@ namespace TestFilter {
 
         result = _(array).filter(listIterator);
         result = _(array).filter('');
-        result = _(array).filter<{a: number}>({a: 42});
+        result = _(array).filter({a: 42});
 
         result = _(list).filter<TResult>(listIterator);
         result = _(list).filter<TResult>('');
-        result = _(list).filter<{a: number}, TResult>({a: 42});
+        result = _(list).filter<TResult>({a: 42});
 
         result = _(dictionary).filter<TResult>(dictionaryIterator);
         result = _(dictionary).filter<TResult>('');
-        result = _(dictionary).filter<{a: number}, TResult>({a: 42});
+        result = _(dictionary).filter<TResult>({a: 42});
     }
 
     {
@@ -3669,15 +3669,15 @@ namespace TestFilter {
 
         result = _(array).chain().filter(listIterator);
         result = _(array).chain().filter('');
-        result = _(array).chain().filter<{a: number}>({a: 42});
+        result = _(array).chain().filter({a: 42});
 
         result = _(list).chain().filter<TResult>(listIterator);
         result = _(list).chain().filter<TResult>('');
-        result = _(list).chain().filter<{a: number}, TResult>({a: 42});
+        result = _(list).chain().filter<TResult>({a: 42});
 
         result = _(dictionary).chain().filter<TResult>(dictionaryIterator);
         result = _(dictionary).chain().filter<TResult>('');
-        result = _(dictionary).chain().filter<{a: number}, TResult>({a: 42});
+        result = _(dictionary).chain().filter<TResult>({a: 42});
     }
 }
 
@@ -3697,48 +3697,48 @@ namespace TestFind {
     result = _.find<TResult>(array, listIterator, 1);
     result = _.find<TResult>(array, '');
     result = _.find<TResult>(array, '', 1);
-    result = _.find<{a: number}, TResult>(array, {a: 42});
-    result = _.find<{a: number}, TResult>(array, {a: 42}, 1);
+    result = _.find<TResult>(array, {a: 42});
+    result = _.find<TResult>(array, {a: 42}, 1);
 
     result = _.find<TResult>(list);
     result = _.find<TResult>(list, listIterator);
     result = _.find<TResult>(list, listIterator, 1);
     result = _.find<TResult>(list, '');
     result = _.find<TResult>(list, '', 1);
-    result = _.find<{a: number}, TResult>(list, {a: 42});
-    result = _.find<{a: number}, TResult>(list, {a: 42}, 1);
+    result = _.find<TResult>(list, {a: 42});
+    result = _.find<TResult>(list, {a: 42}, 1);
 
     result = _.find<TResult>(dictionary);
     result = _.find<TResult>(dictionary, dictionaryIterator);
     result = _.find<TResult>(dictionary, dictionaryIterator, 1);
     result = _.find<TResult>(dictionary, '');
     result = _.find<TResult>(dictionary, '', 1);
-    result = _.find<{a: number}, TResult>(dictionary, {a: 42});
-    result = _.find<{a: number}, TResult>(dictionary, {a: 42}, 1);
+    result = _.find<TResult>(dictionary, {a: 42});
+    result = _.find<TResult>(dictionary, {a: 42}, 1);
 
     result = _(array).find();
     result = _(array).find(listIterator);
     result = _(array).find(listIterator, 1);
     result = _(array).find('');
     result = _(array).find('', 1);
-    result = _(array).find<{a: number}>({a: 42});
-    result = _(array).find<{a: number}>({a: 42}, 1);
+    result = _(array).find({a: 42});
+    result = _(array).find({a: 42}, 1);
 
     result = _(list).find<TResult>();
     result = _(list).find<TResult>(listIterator);
     result = _(list).find<TResult>(listIterator, 1);
     result = _(list).find<TResult>('');
     result = _(list).find<TResult>('', 1);
-    result = _(list).find<{a: number}, TResult>({a: 42});
-    result = _(list).find<{a: number}, TResult>({a: 42}, 1);
+    result = _(list).find<TResult>({a: 42});
+    result = _(list).find<TResult>({a: 42}, 1);
 
     result = _(dictionary).find<TResult>();
     result = _(dictionary).find<TResult>(dictionaryIterator);
     result = _(dictionary).find<TResult>(dictionaryIterator, 1);
     result = _(dictionary).find<TResult>('');
     result = _(dictionary).find<TResult>('', 1);
-    result = _(dictionary).find<{a: number}, TResult>({a: 42});
-    result = _(dictionary).find<{a: number}, TResult>({a: 42}, 1);
+    result = _(dictionary).find<TResult>({a: 42});
+    result = _(dictionary).find<TResult>({a: 42}, 1);
 }
 
 result = <number>_.findLast([1, 2, 3, 4], function (num) {
@@ -5014,25 +5014,25 @@ namespace TestSome {
         result = _.some<SampleObject>(array, listIterator);
         result = _.some<SampleObject>(array, 'a');
         result = _.some<SampleObject>(array, ['a', 42]);
-        result = _.some<{a: number}, SampleObject>(array, {a: 42});
+        result = _.some<SampleObject>(array, {a: 42});
 
         result = _.some<SampleObject>(list);
         result = _.some<SampleObject>(list, listIterator);
         result = _.some<SampleObject>(list, 'a');
         result = _.some<SampleObject>(list, ['a', 42]);
-        result = _.some<{a: number}, SampleObject>(list, {a: 42});
+        result = _.some<SampleObject>(list, {a: 42});
 
         result = _.some<SampleObject>(dictionary);
         result = _.some<SampleObject>(dictionary, dictionaryIterator);
         result = _.some<SampleObject>(dictionary, 'a');
         result = _.some<SampleObject>(dictionary, ['a', 42]);
-        result = _.some<{a: number}, SampleObject>(dictionary, {a: 42});
+        result = _.some<SampleObject>(dictionary, {a: 42});
 
         result = _.some<SampleObject>(numericDictionary);
         result = _.some<SampleObject>(numericDictionary, numericDictionaryIterator);
         result = _.some<SampleObject>(numericDictionary, 'a');
         result = _.some<SampleObject>(numericDictionary, ['a', 42]);
-        result = _.some<{a: number}, SampleObject>(numericDictionary, {a: 42});
+        result = _.some<SampleObject>(numericDictionary, {a: 42});
 
         result = _.some(sampleObject);
         result = _.some(sampleObject, objectIterator);
@@ -5044,31 +5044,31 @@ namespace TestSome {
         result = _(array).some(listIterator);
         result = _(array).some('a');
         result = _(array).some(['a', 42]);
-        result = _(array).some<{a: number}>({a: 42});
+        result = _(array).some({a: 42});
 
         result = _(list).some<SampleObject>();
         result = _(list).some<SampleObject>(listIterator);
         result = _(list).some('a');
         result = _(list).some(['a', 42]);
-        result = _(list).some<{a: number}>({a: 42});
+        result = _(list).some<SampleObject>({a: 42});
 
         result = _(dictionary).some<SampleObject>();
         result = _(dictionary).some<SampleObject>(dictionaryIterator);
         result = _(dictionary).some('a');
         result = _(dictionary).some(['a', 42]);
-        result = _(dictionary).some<{a: number}>({a: 42});
+        result = _(dictionary).some<SampleObject>({a: 42});
 
         result = _(numericDictionary).some<SampleObject>();
         result = _(numericDictionary).some<SampleObject>(numericDictionaryIterator);
         result = _(numericDictionary).some('a');
         result = _(numericDictionary).some(['a', 42]);
-        result = _(numericDictionary).some<{a: number}>({a: 42});
+        result = _(numericDictionary).some<SampleObject>({a: 42});
 
         result = _(sampleObject).some();
         result = _(sampleObject).some(objectIterator);
         result = _(sampleObject).some('a');
         result = _(sampleObject).some(['a', 42]);
-        result = _(sampleObject).some<{a: number}>({a: 42});
+        result = _(sampleObject).some<SampleObject>({a: 42});
     }
 
     {
@@ -5078,31 +5078,31 @@ namespace TestSome {
         result = _(array).chain().some(listIterator);
         result = _(array).chain().some('a');
         result = _(array).chain().some(['a', 42]);
-        result = _(array).chain().some<{a: number}>({a: 42});
+        result = _(array).chain().some({a: 42});
 
         result = _(list).chain().some<SampleObject>();
         result = _(list).chain().some<SampleObject>(listIterator);
         result = _(list).chain().some('a');
         result = _(list).chain().some(['a', 42]);
-        result = _(list).chain().some<{a: number}>({a: 42});
+        result = _(list).chain().some<SampleObject>({a: 42});
 
         result = _(dictionary).chain().some<SampleObject>();
         result = _(dictionary).chain().some<SampleObject>(dictionaryIterator);
         result = _(dictionary).chain().some('a');
         result = _(dictionary).chain().some(['a', 42]);
-        result = _(dictionary).chain().some<{a: number}>({a: 42});
+        result = _(dictionary).chain().some<SampleObject>({a: 42});
 
         result = _(numericDictionary).chain().some<SampleObject>();
         result = _(numericDictionary).chain().some<SampleObject>(numericDictionaryIterator);
         result = _(numericDictionary).chain().some('a');
         result = _(numericDictionary).chain().some(['a', 42]);
-        result = _(numericDictionary).chain().some<{a: number}>({a: 42});
+        result = _(numericDictionary).chain().some<SampleObject>({a: 42});
 
         result = _(sampleObject).chain().some();
         result = _(sampleObject).chain().some(objectIterator);
         result = _(sampleObject).chain().some('a');
         result = _(sampleObject).chain().some(['a', 42]);
-        result = _(sampleObject).chain().some<{a: number}>({a: 42});
+        result = _(sampleObject).chain().some<TResult>({a: 42});
     }
 }
 
diff --git a/lodash/meanBy/index.d.ts b/lodash/meanBy/index.d.ts
index 3004930ef6..e4651a4412 100644
--- a/lodash/meanBy/index.d.ts
+++ b/lodash/meanBy/index.d.ts
@@ -1,3 +1,2 @@
-import * as _ from "../index";
-declare const meanBy: typeof _.meanBy;
-export = meanBy;
+import { meanBy } from "../index";
+export = meanBy;
\ No newline at end of file
diff --git a/lodash/scripts/generate-modules.ts b/lodash/scripts/generate-modules.ts
index 127f1f44c6..395bb7ab4d 100644
--- a/lodash/scripts/generate-modules.ts
+++ b/lodash/scripts/generate-modules.ts
@@ -1,16 +1,124 @@
-// Usage: ts-node generate-modules
+// Usage: ts-node generate-modules.ts
 
 /// <reference types="node" />
 
 import * as fs from "fs";
+import { get, STATUS_CODES } from "http";
+import * as path from "path";
 
-for (const module of allModuleNames()) {
-    if (!fs.existsSync(module)) {
-        fs.mkdirSync(module);
+main().catch(console.error);
+
+async function main() {
+    const all = new Set(allModuleNames());
+    const notOnNpm = new Set(modulesNotOnNpm());
+    for (const n of notOnNpm) {
+        if (!all.has(n)) {
+            throw new Error(n);
+        }
+    }
+
+    for (const module of all) {
+        console.log(module);
+
+        // Generate local module
+        const localDir = path.join("..", module);
+        ensureDir(localDir);
+        fs.writeFileSync(path.join(localDir, "index.d.ts"), `import { ${module} } from "../index";\nexport = ${module};`);
+
+        // Generate non-local module
+        if (!notOnNpm.has(module)) {
+            const dir = path.join("..", "..", `lodash.${module.toLowerCase()}`);
+            ensureDir(dir);
+            fs.writeFileSync(path.join(dir, "index.d.ts"), await globalDefinitionText(module));
+            fs.writeFileSync(path.join(dir, "tsconfig.json"), tsconfig());
+            fs.writeFileSync(path.join(dir, "tslint.json"), tslint());
+        }
     }
-    fs.writeFileSync(`${module}/index.d.ts`, `import { ${module} } from "../index";\nexport = ${module};`);
 }
 
+function ensureDir(dir: string) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+    }
+}
+
+async function globalDefinitionText(moduleName: string): Promise<string> {
+    const fullName = "lodash." + moduleName;
+    const url = `http://registry.npmjs.org/${fullName.toLowerCase()}`;
+    const npmInfo = JSON.parse(await loadString(url));
+    const fullVersion = npmInfo["dist-tags"].latest;
+    const majorMinor = fullVersion.split(".").slice(0, 2).join(".");
+
+    return `
+// Type definitions for ${fullName} ${majorMinor}
+// Project: http://lodash.com/
+// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+import { ${moduleName} } from "lodash";
+export = ${moduleName};
+`.trim() + "\n";
+}
+
+function tsconfig() {
+    return JSON.stringify({
+        "files": [
+            "index.d.ts"
+        ],
+        "compilerOptions": {
+            "module": "commonjs",
+            "target": "es6",
+            "noImplicitAny": true,
+            "noImplicitThis": true,
+            "strictNullChecks": false,
+            "baseUrl": "../",
+            "typeRoots": [
+                "../"
+            ],
+            "types": [],
+            "noEmit": true,
+            "forceConsistentCasingInFileNames": true
+        }
+    }, undefined, 4);
+}
+
+function tslint() {
+    return JSON.stringify({
+        "extends": "../tslint.json"
+    }, undefined, 4);
+}
+
+
+function loadString(url: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+        get(url, (res) => {
+            if (res.statusCode !== 200) {
+                return reject(new Error(`HTTP Error ${res.statusCode}: ${STATUS_CODES[res.statusCode || 500]} for ${url}`))
+            }
+            let rawData = ""
+            res.on("data", chunk => rawData += chunk)
+            res.on("end", () => resolve(rawData))
+        }).on("error", e => reject(e))
+    })
+}
+
+function modulesNotOnNpm() {
+    return [
+        "chain",
+        "each",
+        "eachRight",
+        "extend",
+        "extendWith",
+        "noConflict",
+        "runInContext",
+        "tap",
+        "thru",
+    ];
+}
+
+// Note: "fb" is not a usual module, so it is made by hand.
+
 function allModuleNames() {
     return [
         "add",
@@ -66,7 +174,6 @@ function allModuleNames() {
         "every",
         "extend",
         "extendWith",
-        "fb",
         "fill",
         "filter",
         "find",
diff --git a/lodash/scripts/tsconfig.json b/lodash/scripts/tsconfig.json
new file mode 100644
index 0000000000..a06b8ed24f
--- /dev/null
+++ b/lodash/scripts/tsconfig.json
@@ -0,0 +1,10 @@
+{
+    "compilerOptions": {
+        "target": "es6",
+        "baseUrl": "../..",
+        "typeRoots": [
+            "../../"
+        ],
+        "types": []
+    }
+}
\ No newline at end of file
diff --git a/sequelize-fixtures/index.d.ts b/sequelize-fixtures/index.d.ts
index 2810e7b2ea..b865d91d0c 100644
--- a/sequelize-fixtures/index.d.ts
+++ b/sequelize-fixtures/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/domasx2/sequelize-fixtures
 // Definitions by: Christian Schwarz <https://github.com/cschwarz/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /// <reference types="sequelize" />
 
diff --git a/sequelize/index.d.ts b/sequelize/index.d.ts
index a2a9b6380c..6ff2c3e6df 100644
--- a/sequelize/index.d.ts
+++ b/sequelize/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://sequelizejs.com
 // Definitions by: samuelneff <https://github.com/samuelneff>, Peter Harris <https://github.com/codeanimal>, Ivan Drinchev <https://github.com/drinchev>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 // Based on original work by: samuelneff <https://github.com/samuelneff/sequelize-auto-ts/blob/master/lib/sequelize.d.ts>
 
diff --git a/sequelize/v3/index.d.ts b/sequelize/v3/index.d.ts
index 8b22524878..81a4eab0ed 100644
--- a/sequelize/v3/index.d.ts
+++ b/sequelize/v3/index.d.ts
@@ -2,6 +2,7 @@
 // Project: http://sequelizejs.com
 // Definitions by: samuelneff <https://github.com/samuelneff>, Peter Harris <https://github.com/codeanimal>, Ivan Drinchev <https://github.com/drinchev>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 // Based on original work by: samuelneff <https://github.com/samuelneff/sequelize-auto-ts/blob/master/lib/sequelize.d.ts>
 
diff --git a/umzug/index.d.ts b/umzug/index.d.ts
index 0395d09fd7..af3618df7e 100644
--- a/umzug/index.d.ts
+++ b/umzug/index.d.ts
@@ -2,6 +2,7 @@
 // Project: https://github.com/sequelize/umzug
 // Definitions by: Ivan Drinchev <https://github.com/drinchev/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
 /// <reference types="bluebird" />
 /// <reference types="sequelize" />

From c8b9d48923795415d222a38d73f3c15bfd2bd276 Mon Sep 17 00:00:00 2001
From: Shun Takahashi <s.takahashi@f5.com>
Date: Fri, 27 Jan 2017 10:03:54 -0800
Subject: [PATCH 70/87] Drop namespace and change to flat export model

---
 forever-monitor/forever-monitor-tests.ts |  10 +-
 forever-monitor/index.d.ts               | 173 +++++++++++------------
 2 files changed, 94 insertions(+), 89 deletions(-)

diff --git a/forever-monitor/forever-monitor-tests.ts b/forever-monitor/forever-monitor-tests.ts
index f679c4704a..e44a9c35b0 100644
--- a/forever-monitor/forever-monitor-tests.ts
+++ b/forever-monitor/forever-monitor-tests.ts
@@ -1,6 +1,10 @@
 // Test from https://github.com/foreverjs/forever-monitor
 
 import * as forever from "forever-monitor";
+forever.start('script')
+  .on("start", () => console.log("started"));
+
+forever.kill(10, true);
 
 const child = new (forever.Monitor)('your-filename.js', {
   max: 3,
@@ -12,4 +16,8 @@ child.on('exit', function() {
   console.log('your-filename.js has exited after 3 restarts');
 });
 
-child.start();
+child.start()
+  .on("start", () => console.log("started"))
+  .restart()
+  .stop()
+  .on("exit", () => console.log("STOPPED"))
diff --git a/forever-monitor/index.d.ts b/forever-monitor/index.d.ts
index d59c446f1a..22fa4b0c61 100644
--- a/forever-monitor/index.d.ts
+++ b/forever-monitor/index.d.ts
@@ -4,93 +4,90 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 /// <reference types="node" />
 
-declare namespace forever {
-    export interface SpawnWith {
-        customFds: number[];
-        setsid: boolean;
-        uid: number;
-        gid: number;
-    }
-
-    export interface Options {
-        silent?: boolean;
-        uid?: string;
-        pidFile?: string;
-        max?: number;
-        killTree?: boolean;
-        minUptime?: number;
-        spinSleepTime?: number;
-        command?: string;
-        args?: string[];
-        sourceDir?: string;
-        watch?: boolean;
-        watchIgnoreDotFiles?: boolean;
-        watchIgnorePatters?: string[];
-        watchDirectory?: string;
-        spawnWith?: SpawnWith;
-        env?: { [envKey: string]: string; };
-        cwd?: string;
-        logFile?: string;
-        outFile?: string;
-        errFile?: string;
-        parser?: (command: string, args: string[]) => { command: string, args: string[] };
-    }
-
-    export function start(script: string, options: Options): Monitor;
-    export function kill(pid: number, killTree?: boolean, signal?: string, callback?: () => any): void;
-    export function checkProcess(pid: number): boolean;
-    export const version: string;
-    export class Monitor extends NodeJS.EventEmitter {
-
-        /**
-         * @param script - Location of the target script to run.
-         * @param [options] - Configuration for this instance.
-         */
-        constructor(script: string, options?: Options);
-
-        /**
-         * @description Start the process that this instance is configured for
-         * @param [restart] - Value indicating whether this is a restart.
-         */
-        start(restart?: boolean): this;
-
-        /**
-         * @description Tries to spawn the target Forever child process.
-         */
-        trySpawn(): boolean;
-
-        /**
-         * @description Restarts the target script associated with this instance.
-         */
-        restart(): this;
-
-        /**
-         * @description Stops the target script associated with this instance. Prevents it from auto-respawning
-         */
-        stop(): this;
-
-        /**
-         * @description Kills the ChildProcess object associated with this instance
-         * @param [forceStop] - Value indicating whether short circuit forever auto-restart
-         */
-        kill(forceStop?: boolean): this;
-
-        /**
-         * @description Sends a message to a forked ChildProcess object associated with this instance
-         */
-        send(msg?: any): this;
-
-        /**
-         * respond with JSON for this instance
-         */
-        toString(): string;
-
-        /**
-         * @param command - Command string to parse
-         * @param args - Additional default arguments
-         */
-        parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
-    }
+export interface SpawnWith {
+    customFds: number[];
+    setsid: boolean;
+    uid: number;
+    gid: number;
 }
 
-export = forever;
+export interface Options {
+    silent?: boolean;
+    uid?: string;
+    pidFile?: string;
+    max?: number;
+    killTree?: boolean;
+    minUptime?: number;
+    spinSleepTime?: number;
+    command?: string;
+    args?: string[];
+    sourceDir?: string;
+    watch?: boolean;
+    watchIgnoreDotFiles?: boolean;
+    watchIgnorePatters?: string[];
+    watchDirectory?: string;
+    spawnWith?: SpawnWith;
+    env?: { [envKey: string]: string; };
+    cwd?: string;
+    logFile?: string;
+    outFile?: string;
+    errFile?: string;
+    parser?: (command: string, args: string[]) => { command: string, args: string[] };
+}
+
+export function start(script: string, options?: Options): Monitor;
+export function kill(pid: number, killTree?: boolean, signal?: string, callback?: () => any): void;
+export function checkProcess(pid: number): boolean;
+export const version: string;
+
+export class Monitor extends NodeJS.EventEmitter {
+
+    /**
+     * @param script - Location of the target script to run.
+     * @param [options] - Configuration for this instance.
+     */
+    constructor(script: string, options?: Options);
+
+    /**
+     * @description Start the process that this instance is configured for
+     * @param [restart] - Value indicating whether this is a restart.
+     */
+    start(restart?: boolean): this;
+
+    /**
+     * @description Tries to spawn the target Forever child process.
+     */
+    trySpawn(): boolean;
+
+    /**
+     * @description Restarts the target script associated with this instance.
+     */
+    restart(): this;
+
+    /**
+     * @description Stops the target script associated with this instance. Prevents it from auto-respawning
+     */
+    stop(): this;
+
+    /**
+     * @description Kills the ChildProcess object associated with this instance
+     * @param [forceStop] - Value indicating whether short circuit forever auto-restart
+     */
+    kill(forceStop?: boolean): this;
+
+    /**
+     * @description Sends a message to a forked ChildProcess object associated with this instance
+     */
+    send(msg?: any): this;
+
+    /**
+     * respond with JSON for this instance
+     */
+    toString(): string;
+
+    /**
+     * @param command - Command string to parse
+     * @param args - Additional default arguments
+     */
+    parseCommand(command: string, args?: string[]): (false | { command: string, args?: string[]});
+}

From 088284583fabdcb74a9f245d691cd121fe80114b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Nguyen?=
 <lith-light-g@users.noreply.github.com>
Date: Fri, 27 Jan 2017 20:52:05 +0100
Subject: [PATCH 71/87] Added type definitions for sharp

---
 sharp/index.d.ts     | 642 +++++++++++++++++++++++++++++++++++++++++++
 sharp/sharp-tests.ts | 202 ++++++++++++++
 sharp/tsconfig.json  |  20 ++
 sharp/tslint.json    |   1 +
 4 files changed, 865 insertions(+)
 create mode 100644 sharp/index.d.ts
 create mode 100644 sharp/sharp-tests.ts
 create mode 100644 sharp/tsconfig.json
 create mode 100644 sharp/tslint.json

diff --git a/sharp/index.d.ts b/sharp/index.d.ts
new file mode 100644
index 0000000000..a11385aaa7
--- /dev/null
+++ b/sharp/index.d.ts
@@ -0,0 +1,642 @@
+// Type definitions for sharp 0.17
+// Project: https://github.com/lovell/sharp
+// Definitions by: François Nguyen <https://github.com/lith-light-g>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+///<reference types="node" />
+
+import { Duplex } from "stream";
+
+/**
+ * Creates a sharp instance from an image
+ * @param {string} input Buffer containing JPEG, PNG, WebP, GIF, SVG, TIFF or raw pixel image data, or String containing the path to an JPEG, PNG, WebP, GIF, SVG or TIFF image file.
+ * @param {sharp.SharpOptions} options Object with optional attributes.
+ * @throws {Error} Invalid parameters
+ * @returns {sharp.SharpInstance} A sharp instance that can be used to chain operations
+ */
+declare function sharp(input?: string | Buffer, options?: sharp.SharpOptions): sharp.SharpInstance;
+declare namespace sharp {
+    export const gravity: sharp.GravityEnum;
+    export const strategy: sharp.StrategyEnum;
+    /**
+     * Gets, or when options are provided sets, the limits of libvips' operation cache. Existing entries in the cache will be trimmed after any change in limits. This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
+     * @param {boolean|sharp.CacheOptions} options Object with the cache options, or Boolean where true uses default cache settings and false removes all caching.
+     * @returns {Object}
+     */
+    export function cache(options?: boolean | sharp.CacheOptions): CacheResult;
+    /**
+     * Gets, or when a concurrency is provided sets, the number of threads libvips' should create to process each image.
+     * @param {number} concurrency concurrency value
+     */
+    export function concurrency(threads?: number): number;
+    /**
+     * Provides access to internal task counters.
+     * @returns {sharp.SharpCounters} Object containing task counters
+     */
+    export function counters(): sharp.SharpCounters;
+    /**
+     * Get and set use of SIMD vector unit instructions.
+     * @param {boolean} enable enable or disable use of SIMD vector unit instructions
+     * @returns {boolean} true if usage of SIMD vector unit instructions is enabled
+     */
+    export function simd(enable?: boolean): boolean;
+    export const kernel: sharp.KernelEnum;
+    export const interpolator: sharp.InterpolatorEnum;
+    /**
+     * Object containing nested boolean values representing the available input and output formats/methods.
+     */
+    export const format: FormatEnum;
+    /** An EventEmitter that emits a change event when a task is either queued, waiting for libuv to provide a worker thread, complete */
+    export const queue: NodeJS.EventEmitter;
+    /** An Object containing the version numbers of libvips and its dependencies. */
+    export const versions: string[];
+    export const bool: BoolEnum;
+
+    interface SharpInstance extends Duplex {
+        /**
+         * Fast access to image metadata without decoding any compressed image data.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        metadata(callback: (err: Error, metadata: Metadata) => void): SharpInstance;
+        /**
+         * Fast access to image metadata without decoding any compressed image data.
+         * @returns {Promise<Metadata>} A promise that fulfills with a metadata object.
+         */
+        metadata(): Promise<Metadata>;
+        /**
+         * Take a "snapshot" of the Sharp instance, returning a new instance.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        clone(): SharpInstance;
+        /**
+         * An advanced setting that switches the libvips access method to VIPS_ACCESS_SEQUENTIAL.
+         * @param {boolean} sequentialRead true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        sequentialRead(sequentialRead?: boolean): SharpInstance;
+        /**
+         * Do not process input images where the number of pixels (width _ height) exceeds this limit.
+         * @param {number|boolean} pixels An integral Number of pixels, zero or false to remove limit, true to use default limit.
+         * @throws {Error} Invalid limit
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        limitInputPixels(pixels: number | boolean): SharpInstance;
+        /**
+         * Resize image to width x height. By default, the resized image is centre cropped to the exact size specified.
+         * @param {number} width pixels wide the resultant image should be, between 1 and 16383 (0x3FFF). Use null or  undefined to auto-scale the width to match the height.
+         * @param {number} height pixels high the resultant image should be, between 1 and 16383. Use null or undefined to auto-scale the height to match the width.
+         * @param {ResizeOptions} options resize options
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        resize(width?: number, height?: number, options?: ResizeOptions): SharpInstance;
+        /**
+         * Crop the resized image to the exact size specified, the default behaviour.
+         * @param {number|string} crop A member of sharp.gravity to crop to an edge/corner or sharp.strategy to crop dynamically. (optional, default 'centre')
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        crop(crop?: number | string): SharpInstance;
+        /**
+         * Preserving aspect ratio, resize the image to the maximum width or height specified then embed on a background of the exact width and height specified.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        embed(): SharpInstance;
+        /**
+         * Preserving aspect ratio, resize the image to be as large as possible while ensuring its dimensions are less than or equal to the width and height specified.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        max(): SharpInstance;
+        /**
+         * Preserving aspect ratio, resize the image to be as small as possible while ensuring its dimensions are greater than or equal to the width and height specified.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        min(): SharpInstance;
+        /**
+         * Do not enlarge the output image if the input image width or height are already less than the required dimensions.
+         * @param {boolean} withoutEnlargement true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        withoutEnlargement(withoutEnlargement?: boolean): SharpInstance;
+        /**
+         * Ignoring the aspect ratio of the input, stretch the image to the exact width and/or height provided via resize.
+         */
+        ignoreAspectRatio(): SharpInstance;
+        /**
+         * Extract a region of the image.
+         * @param {Region} region Region to extract
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        extract(region: Region): SharpInstance;
+        /**
+         * Trim "boring" pixels from all edges that contain values within a percentage similarity of the top-left pixel.
+         * @param {number} tolerance value between 1 and 99 representing the percentage similarity. (optional, default 10)
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        trim(tolerance?: number): SharpInstance;
+        /**
+         * Set the background for the embed, flatten and extend operations. The default background is {r: 0, g: 0, b: 0, alpha: 1}, black without transparency.
+         * @param {RGBA|string} rgba String or Object parsed by the color module to extract values for red, green, blue and alpha.
+         * @throws {Error} Invalid parameter
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        background(rgba?: RGBA | string): SharpInstance; // Wait for typings to fetch latest color typings from DT
+        /**
+         * Merge alpha transparency channel, if any, with background.
+         * @param {boolean} flatten true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        flatten(flatten?: boolean): SharpInstance;
+        /**
+         * Extends/pads the edges of the image with the colour provided to the background method.
+         * @param {number|ExtendOptions} extend single pixel count to add to all edges or an Object with per-edge counts
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        extend(extend: number | ExtendOptions): SharpInstance;
+        /**
+         * Produce the "negative" of the image.
+         * @param {boolean} negate true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        negate(negate?: boolean): SharpInstance;
+        /**
+         * Rotate the output image by either an explicit angle or auto-orient based on the EXIF Orientation tag.
+         * @param {number} angle 0, 90, 180 or 270. (optional, default auto)
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        rotate(angle?: number): SharpInstance;
+        /**
+         * Flip the image about the vertical Y axis.
+         * @param {boolean} flip true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        flip(flip?: boolean): SharpInstance;
+        /**
+         * Flop the image about the horizontal X axis.
+         * @param {boolean} flop true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        flop(flop?: boolean): SharpInstance;
+        /**
+         * Blur the image.
+         * @param {number} sigma a value between 0.3 and 1000 representing the sigma of the Gaussian mask, where sigma = 1 + radius / 2.
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        blur(sigma?: number): SharpInstance;
+        /**
+         * Convolve the image with the specified kernel.
+         * @param {Kernel} kernel the specified kernel
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        convolve(kernel: Kernel): SharpInstance;
+        /**
+         * Sharpen the image.
+         * @param {number} sigma the sigma of the Gaussian mask, where sigma = 1 + radius / 2.
+         * @param {number} flat the level of sharpening to apply to "flat" areas. (optional, default 1.0)
+         * @param {number} jagged the level of sharpening to apply to "jagged" areas. (optional, default 2.0)
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        sharpen(sigma?: number, flat?: number, jagged?: number): SharpInstance;
+        /**
+         * Any pixel value greather than or equal to the threshold value will be set to 255, otherwise it will be set to 0.
+         * @param {number} threshold a value in the range 0-255 representing the level at which the threshold will be applied. (optional, default 128)
+         * @param {ThresholdOptions} options threshold options
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        threshold(threshold?: number, options?: ThresholdOptions): SharpInstance;
+        /**
+         * Apply a gamma correction by reducing the encoding (darken) pre-resize at a factor of 1/gamma then increasing the encoding (brighten) post-resize at a factor of gamma.
+         * @param {number} gamma value between 1.0 and 3.0. (optional, default 2.2)
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        gamma(gamma?: number): SharpInstance;
+        /**
+         * Alternative spelling of greyscale.
+         * Convert to 8-bit greyscale; 256 shades of grey. This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use gamma() with greyscale() for the best results. By default the output image will be web-friendly sRGB and contain three (identical) color channels. This may be overridden by other sharp operations such as toColourspace('b-w'), which will produce an output image containing one color channel. An alpha channel may be present, and will be unchanged by the operation.
+         * @param {boolean} grayscale true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        grayscale(grayscale?: boolean): SharpInstance;
+        /**
+         * Convert to 8-bit greyscale; 256 shades of grey. This is a linear operation. If the input image is in a non-linear colour space such as sRGB, use gamma() with greyscale() for the best results. By default the output image will be web-friendly sRGB and contain three (identical) color channels. This may be overridden by other sharp operations such as toColourspace('b-w'), which will produce an output image containing one color channel. An alpha channel may be present, and will be unchanged by the operation.
+         * @param {boolean} greyscale true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        greyscale(greyscale?: boolean): SharpInstance;
+        /**
+         * Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+         * @param {boolean} normalize true to enable and false to disable (defaults to true)
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        normalize(normalize?: boolean): SharpInstance;
+        /**
+         * Alternative spelling of normalise.
+         * Enhance output image contrast by stretching its luminance to cover the full dynamic range.
+         * @param {boolean} normalise true to enable and false to disable (defaults to true)
+         */
+        normalise(normalise?: boolean): SharpInstance;
+        /**
+         * Overlay (composite) an image over the processed (resized, extracted etc.) image.
+         * @param {string|Buffer} image Buffer containing image data or String containing the path to an image file.
+         * @param {OverlayOptions} options overlay options
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        overlayWith(image: string | Buffer, options?: OverlayOptions): SharpInstance;
+        /**
+         * Set the output colourspace.
+         * @param {string} colourspace output colourspace e.g. srgb, rgb, cmyk, lab, b-w ...
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        toColourspace(colourspace?: string): SharpInstance;
+        /**
+         * Alternative spelling of toColourspace.
+         * Set the output colorspace.
+         * @param {string} colorspace output colourspace e.g. srgb, rgb, cmyk, lab, b-w ...
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        toColorspace(colorspace: string): SharpInstance;
+        /**
+         * Extract a single channel from a multi-channel image.
+         * @param {number|string} channel zero-indexed band number to extract, or red, green or blue as alternative to 0, 1 or 2 respectively.
+         * @throws {Error} Invalid channel
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        extractChannel(channel: number | string): SharpInstance;
+        /**
+         * Join one or more channels to the image. The meaning of the added channels depends on the output colourspace, set with toColourspace().
+         * @param {string|string[]|Buffer|Buffer[]} channels one or more images (file paths, Buffers).
+         * @param {{raw:Raw}} options image options
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        joinChannel(channels: string | string[] | Buffer | Buffer[], options?: { raw: Raw }): SharpInstance;
+        /**
+         * Perform a bitwise boolean operation on all input image channels (bands) to produce a single channel output image.
+         * @param {string} boolOp one of and, or or eor to perform that bitwise operation, like the C logic operators &, | and ^ respectively.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        bandbool(boolOp: string): SharpInstance;
+        /**
+         * Perform a bitwise boolean operation with operand image.
+         * @param {string|Buffer} image Buffer containing image data or String containing the path to an image file.
+         * @param {strip} operator one of and, or or eor to perform that bitwise operation, like the C logic operators &, | and ^ respectively.
+         * @param {{raw:Raw}} options describes operand when using raw pixel data.
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        boolean(operand: string | Buffer, operator: string, options?: { raw: Raw }): SharpInstance;
+        /**
+         * Write output image data to a file.
+         * @param {string} fileOut The path to write the image data to.
+         * @param {Function} callback Callback function called on completion with two arguments (err, info).  info contains the output image format, size (bytes), width, height and channels.
+         * @throws {Error} Invalid parameters
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        toFile(fileOut: string, callback: (err: Error, info: OutputInfo) => void): SharpInstance;
+        /**
+         * Write output image data to a file.
+         * @param {string} fileOut The path to write the image data to.
+         * @throws {Error} Invalid parameters
+         * @returns {Promise<OutputInfo>} A promise that fulfills with an object containing informations on the resulting file
+         */
+        toFile(fileOut: string): Promise<OutputInfo>;
+        /**
+         * Write output to a Buffer. JPEG, PNG, WebP, and RAW output are supported. By default, the format will match the input image, except GIF and SVG input which become PNG output.
+         * @param {Function} callback Callback function called on completion with three arguments (err, buffer, info). err is an error message, if any. buffer is the output image data. info contains the output image format, size (bytes), width, height and channels. A Promises/A+ promise is returned when callback is not provided.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        toBuffer(callback: (err: Error, buffer: Buffer, info: OutputInfo) => void): SharpInstance;
+        /**
+         * Write output to a Buffer. JPEG, PNG, WebP, and RAW output are supported. By default, the format will match the input image, except GIF and SVG input which become PNG output.
+         * @returns {Promise<Buffer>} A promise that fulfills with the resulting Buffer
+         */
+        toBuffer(): Promise<Buffer>;
+        /**
+         * Use these JPEG options for output image.
+         * @param {JpegOptions} options Output options.
+         * @throws {Error} Invalid options
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        jpeg(options?: JpegOptions): SharpInstance;
+        /**
+         * Use these PNG options for output image.
+         * @param {PngOptions} options Output options.
+         * @throws {Error} Invalid options
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        png(options?: PngOptions): SharpInstance;
+        /**
+         * Use these WebP options for output image.
+         * @param {OutputOptions} options Output options.
+         * @throws {Error} Invalid options
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        webp(options?: OutputOptions): SharpInstance;
+        /**
+         * Use these TIFF options for output image.
+         * @param {OutputOptions} options Output options.
+         * @throws {Error} Invalid options
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        tiff(options?: OutputOptions): SharpInstance;
+        /**
+         * Force output to be raw, uncompressed uint8 pixel data.
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        raw(): SharpInstance;
+        /**
+         * Force output to a given format.
+         * @param {string|AvailableFormatInfo} format a String or an Object with an 'id' attribute
+         * @param {OutputOptions|JpegOptions|PngOptions} options output options
+         * @throws {Error} Unsupported format or options
+         * @returns {SharpInstance} A sharp instance that can be used to chain operations
+         */
+        toFormat(format: string | AvailableFormatInfo, options?: OutputOptions | JpegOptions | PngOptions): SharpInstance;
+        /**
+         * Include all metadata (EXIF, XMP, IPTC) from the input image in the output image. The default behaviour, when withMetadata is not used, is to strip all metadata and convert to the device-independent sRGB colour space. This will also convert to and add a web-friendly sRGB ICC profile.
+         * @param {Metadata}
+         * @throws {Error} Invalid parameters.
+         */
+        withMetadata(metadata?: Metadata): SharpInstance;
+        /**
+         * Use tile-based deep zoom (image pyramid) output. Set the format and options for tile images via the  toFormat, jpeg, png or webp functions. Use a .zip or .szi file extension with toFile to write to a compressed archive file format.
+         * @param {TileOptions} options options
+         */
+        tile(options: TileOptions): SharpInstance;
+    }
+
+    export interface SharpOptions {
+        /** integral number representing the DPI for vector images. */
+        density?: number;
+        /** describes raw pixel image data. */
+        raw?: Raw;
+    }
+
+    export interface CacheOptions {
+        /** is the maximum memory in MB to use for this cache */
+        memory?: number;
+        /** is the maximum number of files to hold open */
+        files?: number;
+        /** is the maximum number of operations to cache */
+        items?: number;
+    }
+
+    export interface SharpCounters {
+        queue: number;
+        process: number;
+    }
+
+    export interface Raw {
+        width: number;
+        height: number;
+        channels: number;
+    }
+
+    export interface Metadata {
+        /** Name of decoder used to decompress image data e.g. jpeg, png, webp, gif, svg */
+        format?: string;
+        /** Number of pixels wide */
+        width?: number;
+        /** Number of pixels high */
+        height?: number;
+        /** Name of colour space interpretation e.g. srgb, rgb, cmyk, lab, b-w ... */
+        space?: string;
+        /** Number of bands e.g. 3 for sRGB, 4 for CMYK */
+        channels?: number;
+        /** Number of pixels per inch (DPI), if present */
+        density?: number;
+        /** Boolean indicating the presence of an embedded ICC profile */
+        hasProfile?: boolean;
+        /** Boolean indicating the presence of an alpha transparency channel */
+        hasAlpha?: boolean;
+        /** Number value of the EXIF Orientation header, if present */
+        orientation?: number;
+        /** Buffer containing raw EXIF data, if present */
+        exif?: Buffer;
+        /** Buffer containing raw ICC profile data, if present */
+        icc?: Buffer;
+    }
+
+    export interface JpegOptions extends OutputOptions {
+        /** Use progressive (interlace) scan (optional, default false) */
+        progressive?: boolean;
+        /** Set to '4:4:4' to prevent chroma subsampling when quality <= 90 (optional, default '4:2:0') */
+        chromaSubsampling?: string;
+        /** Apply trellis quantisation, requires mozjpeg (optional, default  false) */
+        trellisQuantisation?: boolean;
+        /** Apply overshoot deringing, requires mozjpeg (optional, default  false) */
+        overshootDeringing?: boolean;
+        /** Optimise progressive scans, forces progressive, requires mozjpeg (optional, default false) */
+        optimiseScans?: boolean;
+        /** Alternative spelling of optimiseScans (optional, default false) */
+        optimizeScans?: boolean;
+    }
+
+    export interface PngOptions {
+        /** Use progressive (interlace) scan (optional, default false) */
+        progressive?: boolean;
+        /** zlib compression level (optional, default 6) */
+        compressionLevel?: number;
+        /** Use adaptive row filtering (optional, default true) */
+        adaptiveFiltering?: boolean;
+        /** Force PNG output, otherwise attempt to use input format (optional, default  true) */
+        force?: boolean;
+    }
+
+    export interface OutputOptions {
+        /** Quality, integer 1-100 (optional, default 80) */
+        quality?: number;
+        /** Force format output, otherwise attempt to use input format (optional, default true) */
+        force?: boolean;
+    }
+
+    export interface ResizeOptions {
+        /** the kernel to use for image reduction. (optional, default 'lanczos3') */
+        kernel?: string;
+        /** the interpolator to use for image enlargement. (optional, default 'bicubic') */
+        interpolator?: string;
+        /** use magick centre sampling convention instead of corner sampling. (optional, default false) */
+        centreSampling?: boolean;
+        /** alternative spelling of centreSampling. (optional, default false) */
+        centerSampling?: boolean;
+    }
+
+    export interface Region {
+        /** zero-indexed offset from left edge */
+        left?: number;
+        /** zero-indexed offset from top edge */
+        top?: number;
+        /** dimension of extracted image */
+        width?: number;
+        /** dimension of extracted image */
+        height?: number;
+    }
+
+    export interface ExtendOptions {
+        top?: number;
+        left?: number;
+        bottom?: number;
+        right?: number;
+    }
+
+    export interface RGBA {
+        r?: number;
+        g?: number;
+        b?: number;
+        alpha?: number;
+    }
+
+    export interface Kernel {
+        /** width of the kernel in pixels. */
+        width: number;
+        /** height of the kernel in pixels. */
+        height: number;
+        /** Array of length width*height containing the kernel values. */
+        kernel: number[];
+        /** the scale of the kernel in pixels. (optional, default sum) */
+        scale?: number;
+        /** the offset of the kernel in pixels. (optional, default 0) */
+        offset?: number;
+    }
+
+    export interface ThresholdOptions {
+        /** convert to single channel greyscale. (optional, default true) */
+        greyscale?: boolean;
+        /** alternative spelling for greyscale. (optional, default true) */
+        grayscale?: boolean;
+    }
+
+    export interface OverlayOptions {
+        /** gravity at which to place the overlay. (optional, default 'centre') */
+        gravity?: number;
+        /** the pixel offset from the top edge. */
+        top?: number;
+        /** the pixel offset from the left edge. */
+        left?: number;
+        /** set to true to repeat the overlay image across the entire image with the given  gravity. (optional, default false) */
+        tile?: boolean;
+        /** set to true to apply only the alpha channel of the overlay image to the input image, giving the appearance of one image being cut out of another. (optional, default false) */
+        cutout?: boolean;
+        /** describes overlay when using raw pixel data. */
+        raw?: Raw;
+    }
+
+    export interface TileOptions {
+        /** Tile size in pixels, a value between 1 and 8192. (optional, default 256) */
+        size?: number;
+        /** Tile overlap in pixels, a value between 0 and 8192. (optional, default 0) */
+        overlap?: number;
+        /** Tile container, with value fs (filesystem) or zip (compressed file). (optional, default 'fs') */
+        container?: string;
+        /** Filesystem layout, possible values are dz, zoomify or google. (optional, default  'dz') */
+        layout?: string;
+    }
+
+    export interface OutputInfo {
+        format: string;
+        size: number;
+        width: number;
+        height: number;
+        channels: number;
+    }
+
+    export interface AvailableFormatInfo {
+        id: string;
+        input: { file: boolean; buffer: boolean; stream: boolean; };
+        output: { file: boolean; buffer: boolean; stream: boolean; };
+    }
+
+    export interface KernelEnum {
+        cubic: string;
+        lanczos2: string;
+        lanczos3: string;
+    }
+
+    export interface InterpolatorEnum {
+        nearest: string;
+        bilinear: string;
+        bicubic: string;
+        nohalo: string;
+        lbb: string;
+        locallyBoundedBicubic: string;
+        vsqbs: string;
+        vertexSplitQuadraticBasisSpline: string;
+    }
+
+    export interface BoolEnum {
+        and: string;
+        or: string;
+        eor: string;
+    }
+
+    export interface ColourspaceEnum {
+        multiband: string;
+        "b-w": string;
+        bw: string;
+        cmyk: string;
+        srgb: string;
+    }
+
+    export interface GravityEnum {
+        north: number;
+        northeast: number;
+        southeast: number;
+        south: number;
+        southwest: number;
+        west: number;
+        northwest: number;
+        east: number;
+        center: number;
+        centre: number;
+    }
+
+    export interface StrategyEnum {
+        entropy: number;
+        attention: number;
+    }
+
+    export interface FormatEnum {
+        jpeg: AvailableFormatInfo;
+        png: AvailableFormatInfo;
+        webp: AvailableFormatInfo;
+        raw: AvailableFormatInfo;
+        tiff: AvailableFormatInfo;
+        dz: AvailableFormatInfo;
+        input: AvailableFormatInfo;
+        magick: AvailableFormatInfo;
+        openslide: AvailableFormatInfo;
+        ppm: AvailableFormatInfo;
+        fits: AvailableFormatInfo;
+        gif: AvailableFormatInfo;
+        svg: AvailableFormatInfo;
+        pdf: AvailableFormatInfo;
+        v: AvailableFormatInfo;
+    }
+
+    interface FormatObject extends FormatEnum {
+        /**
+         * Returns an Object containing nested boolean values representing the available input and output formats/methods.
+         * @returns Object containing available formats
+         */
+        (): FormatEnum;
+    }
+
+    export interface CacheResult {
+        memory: { current: number; high: number; max: number; };
+        files: { current: number; max: number; };
+        items: { current: number; max: number; };
+    }
+}
+
+export = sharp;
\ No newline at end of file
diff --git a/sharp/sharp-tests.ts b/sharp/sharp-tests.ts
new file mode 100644
index 0000000000..00c318feb9
--- /dev/null
+++ b/sharp/sharp-tests.ts
@@ -0,0 +1,202 @@
+import * as sharp from "sharp";
+import { createReadStream, createWriteStream } from "fs";
+
+// Test samples taken from the official documentation
+
+const input: Buffer = new Buffer(0);
+const readableStream: NodeJS.ReadableStream = createReadStream(input);
+const writableStream: NodeJS.WritableStream = createWriteStream(input);
+
+sharp(input)
+    .extractChannel('green')
+    .toFile('input_green.jpg', function(err, info) {
+        // info.channels === 1
+        // input_green.jpg contains the green channel of the input image
+    });
+
+sharp('3-channel-rgb-input.png')
+    .bandbool(sharp.bool.and)
+    .toFile('1-channel-output.png', function(err, info) {
+        // The output will be a single channel image where each pixel `P = R & G & B`.
+        // If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
+        // then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
+    });
+
+sharp('input.png')
+    .rotate(180)
+    .resize(300)
+    .flatten()
+    .background('#ff6600')
+    .overlayWith('overlay.png', { gravity: sharp.gravity.southeast })
+    .sharpen()
+    .withMetadata()
+    .webp({
+        quality: 90
+    })
+    .toBuffer()
+    .then(function(outputBuffer: Buffer) {
+        // outputBuffer contains upside down, 300px wide, alpha channel flattened
+        // onto orange background, composited with overlay.png with SE gravity,
+        // sharpened, with metadata, 90% quality WebP image data. Phew!
+    });
+
+sharp('input.jpg')
+    .resize(300, 200)
+    .toFile('output.jpg', function(err: Error) {
+        // output.jpg is a 300 pixels wide and 200 pixels high image
+        // containing a scaled and cropped version of input.jpg
+    });
+
+var transformer = sharp()
+    .resize(300)
+    .on('info', function(info: sharp.OutputInfo) {
+        console.log('Image height is ' + info.height);
+    });
+readableStream.pipe(transformer).pipe(writableStream);
+
+console.log(sharp.format);
+console.log(sharp.versions);
+
+sharp.queue.on('change', function(queueLength: number) {
+    console.log('Queue contains ' + queueLength + ' task(s)');
+});
+
+let pipeline: sharp.SharpInstance = sharp().rotate();
+pipeline.clone().resize(800, 600).pipe(writableStream);
+pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(writableStream);
+readableStream.pipe(pipeline);
+// firstWritableStream receives auto-rotated, resized readableStream
+// secondWritableStream receives auto-rotated, extracted region of readableStream
+
+const image: sharp.SharpInstance = sharp(input);
+image
+    .metadata()
+    .then<Buffer|undefined>(function(metadata: sharp.Metadata) {
+        if (metadata.width) {
+            return image
+                .resize(Math.round(metadata.width / 2))
+                .webp()
+                .toBuffer();
+        }
+    })
+    .then(function(data: Buffer) {
+        // data contains a WebP image half the width and height of the original JPEG
+    });
+
+pipeline = sharp()
+    .rotate()
+    .resize(undefined, 200)
+    .toBuffer(function(err: Error, outputBuffer: Buffer, info: sharp.OutputInfo) {
+        // outputBuffer contains 200px high JPEG image data,
+        // auto-rotated using EXIF Orientation tag
+        // info.width and info.height contain the dimensions of the resized image
+    });
+readableStream.pipe(pipeline);
+
+sharp(input)
+    .extract({ left: 0, top: 0, width: 100, height: 100 })
+    .toFile("output", function(err: Error) {
+        // Extract a region of the input image, saving in the same format.
+    });
+
+sharp(input)
+    .extract({ left: 0, top: 0, width: 100, height: 100 })
+    .resize(200, 200)
+    .extract({ left: 0, top: 0, width: 100, height: 100 })
+    .toFile("output", function(err: Error) {
+        // Extract a region, resize, then extract from the resized image
+    });
+
+// Resize to 140 pixels wide, then add 10 transparent pixels
+// to the top, left and right edges and 20 to the bottom edge
+sharp(input)
+    .resize(140)
+    .background({ r: 0, g: 0, b: 0, alpha: 0 })
+    .extend({ top: 10, bottom: 20, left: 10, right: 10 });
+
+sharp(input)
+    .convolve({
+        width: 3,
+        height: 3,
+        kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1]
+    })
+    .raw()
+    .toBuffer(function(err: Error, data: Buffer, info: sharp.OutputInfo) {
+        // data contains the raw pixel data representing the convolution
+        // of the input image with the horizontal Sobel operator
+    });
+
+sharp('input.tiff')
+    .png()
+    .tile({
+        size: 512
+    })
+    .toFile('output.dz', function(err: Error, info: sharp.OutputInfo) {
+        // output.dzi is the Deep Zoom XML definition
+        // output_files contains 512x512 tiles grouped by zoom level
+    });
+
+sharp(input)
+    .resize(200, 300, {
+        kernel: sharp.kernel.lanczos2,
+        interpolator: sharp.interpolator.nohalo
+    })
+    .background('white')
+    .embed()
+    .toFile('output.tiff')
+    .then(function() {
+        // output.tiff is a 200 pixels wide and 300 pixels high image
+        // containing a lanczos2/nohalo scaled version, embedded on a white canvas,
+        // of the image data in inputBuffer
+    });
+
+transformer = sharp()
+    .resize(200, 200)
+    .crop(sharp.strategy.entropy)
+    .on('error', function(err: Error) {
+        console.log(err);
+    });
+// Read image data from readableStream
+// Write 200px square auto-cropped image data to writableStream
+readableStream.pipe(transformer).pipe(writableStream);
+
+sharp('input.gif')
+    .resize(200, 300)
+    .background({ r: 0, g: 0, b: 0, alpha: 0 })
+    .embed()
+    .toFormat(sharp.format.webp)
+    .toBuffer(function(err: Error, outputBuffer: Buffer) {
+        if (err) {
+            throw err;
+        }
+        // outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
+        // containing a scaled version, embedded on a transparent canvas, of input.gif
+    });
+
+sharp(input)
+    .resize(200, 200)
+    .max()
+    .toFormat('jpeg')
+    .toBuffer()
+    .then(function(outputBuffer: Buffer) {
+        // outputBuffer contains JPEG image data no wider than 200 pixels and no higher
+        // than 200 pixels regardless of the inputBuffer image dimensions
+    });
+
+const stats = sharp.cache();
+
+sharp.cache({ items: 200 });
+sharp.cache({ files: 0 });
+sharp.cache(false);
+
+const threads = sharp.concurrency(); // 4
+sharp.concurrency(2); // 2
+sharp.concurrency(0); // 4
+
+const counters = sharp.counters(); // { queue: 2, process: 4 }
+
+let simd: boolean = sharp.simd();
+// simd is `true` if SIMD is currently enabled
+
+simd = sharp.simd(true);
+// attempts to enable the use of SIMD, returning true if available
diff --git a/sharp/tsconfig.json b/sharp/tsconfig.json
new file mode 100644
index 0000000000..d896ff0b33
--- /dev/null
+++ b/sharp/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "types",
+        "typeRoots": [
+            "types"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "sharp-tests.ts"
+    ]
+}
\ No newline at end of file
diff --git a/sharp/tslint.json b/sharp/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/sharp/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 9af924c0809717524634c35bb48c6ebfccaa411d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Nguyen?=
 <lith-light-g@users.noreply.github.com>
Date: Fri, 27 Jan 2017 21:11:18 +0100
Subject: [PATCH 72/87] Fixed tsconfig.json and removed exports from namespace

---
 sharp/index.d.ts    | 78 ++++++++++++++++++++++-----------------------
 sharp/tsconfig.json |  4 +--
 2 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/sharp/index.d.ts b/sharp/index.d.ts
index a11385aaa7..119e1d9b10 100644
--- a/sharp/index.d.ts
+++ b/sharp/index.d.ts
@@ -16,41 +16,41 @@ import { Duplex } from "stream";
  */
 declare function sharp(input?: string | Buffer, options?: sharp.SharpOptions): sharp.SharpInstance;
 declare namespace sharp {
-    export const gravity: sharp.GravityEnum;
-    export const strategy: sharp.StrategyEnum;
+    const gravity: sharp.GravityEnum;
+    const strategy: sharp.StrategyEnum;
     /**
      * Gets, or when options are provided sets, the limits of libvips' operation cache. Existing entries in the cache will be trimmed after any change in limits. This method always returns cache statistics, useful for determining how much working memory is required for a particular task.
      * @param {boolean|sharp.CacheOptions} options Object with the cache options, or Boolean where true uses default cache settings and false removes all caching.
      * @returns {Object}
      */
-    export function cache(options?: boolean | sharp.CacheOptions): CacheResult;
+    function cache(options?: boolean | sharp.CacheOptions): CacheResult;
     /**
      * Gets, or when a concurrency is provided sets, the number of threads libvips' should create to process each image.
      * @param {number} concurrency concurrency value
      */
-    export function concurrency(threads?: number): number;
+    function concurrency(threads?: number): number;
     /**
      * Provides access to internal task counters.
      * @returns {sharp.SharpCounters} Object containing task counters
      */
-    export function counters(): sharp.SharpCounters;
+    function counters(): sharp.SharpCounters;
     /**
      * Get and set use of SIMD vector unit instructions.
      * @param {boolean} enable enable or disable use of SIMD vector unit instructions
      * @returns {boolean} true if usage of SIMD vector unit instructions is enabled
      */
-    export function simd(enable?: boolean): boolean;
-    export const kernel: sharp.KernelEnum;
-    export const interpolator: sharp.InterpolatorEnum;
+    function simd(enable?: boolean): boolean;
+    const kernel: sharp.KernelEnum;
+    const interpolator: sharp.InterpolatorEnum;
     /**
      * Object containing nested boolean values representing the available input and output formats/methods.
      */
-    export const format: FormatEnum;
+    const format: FormatEnum;
     /** An EventEmitter that emits a change event when a task is either queued, waiting for libuv to provide a worker thread, complete */
-    export const queue: NodeJS.EventEmitter;
+    const queue: NodeJS.EventEmitter;
     /** An Object containing the version numbers of libvips and its dependencies. */
-    export const versions: string[];
-    export const bool: BoolEnum;
+    const versions: string[];
+    const bool: BoolEnum;
 
     interface SharpInstance extends Duplex {
         /**
@@ -376,14 +376,14 @@ declare namespace sharp {
         tile(options: TileOptions): SharpInstance;
     }
 
-    export interface SharpOptions {
+    interface SharpOptions {
         /** integral number representing the DPI for vector images. */
         density?: number;
         /** describes raw pixel image data. */
         raw?: Raw;
     }
 
-    export interface CacheOptions {
+    interface CacheOptions {
         /** is the maximum memory in MB to use for this cache */
         memory?: number;
         /** is the maximum number of files to hold open */
@@ -392,18 +392,18 @@ declare namespace sharp {
         items?: number;
     }
 
-    export interface SharpCounters {
+    interface SharpCounters {
         queue: number;
         process: number;
     }
 
-    export interface Raw {
+    interface Raw {
         width: number;
         height: number;
         channels: number;
     }
 
-    export interface Metadata {
+    interface Metadata {
         /** Name of decoder used to decompress image data e.g. jpeg, png, webp, gif, svg */
         format?: string;
         /** Number of pixels wide */
@@ -428,7 +428,7 @@ declare namespace sharp {
         icc?: Buffer;
     }
 
-    export interface JpegOptions extends OutputOptions {
+    interface JpegOptions extends OutputOptions {
         /** Use progressive (interlace) scan (optional, default false) */
         progressive?: boolean;
         /** Set to '4:4:4' to prevent chroma subsampling when quality <= 90 (optional, default '4:2:0') */
@@ -443,7 +443,7 @@ declare namespace sharp {
         optimizeScans?: boolean;
     }
 
-    export interface PngOptions {
+    interface PngOptions {
         /** Use progressive (interlace) scan (optional, default false) */
         progressive?: boolean;
         /** zlib compression level (optional, default 6) */
@@ -454,14 +454,14 @@ declare namespace sharp {
         force?: boolean;
     }
 
-    export interface OutputOptions {
+    interface OutputOptions {
         /** Quality, integer 1-100 (optional, default 80) */
         quality?: number;
         /** Force format output, otherwise attempt to use input format (optional, default true) */
         force?: boolean;
     }
 
-    export interface ResizeOptions {
+    interface ResizeOptions {
         /** the kernel to use for image reduction. (optional, default 'lanczos3') */
         kernel?: string;
         /** the interpolator to use for image enlargement. (optional, default 'bicubic') */
@@ -472,7 +472,7 @@ declare namespace sharp {
         centerSampling?: boolean;
     }
 
-    export interface Region {
+    interface Region {
         /** zero-indexed offset from left edge */
         left?: number;
         /** zero-indexed offset from top edge */
@@ -483,21 +483,21 @@ declare namespace sharp {
         height?: number;
     }
 
-    export interface ExtendOptions {
+    interface ExtendOptions {
         top?: number;
         left?: number;
         bottom?: number;
         right?: number;
     }
 
-    export interface RGBA {
+    interface RGBA {
         r?: number;
         g?: number;
         b?: number;
         alpha?: number;
     }
 
-    export interface Kernel {
+    interface Kernel {
         /** width of the kernel in pixels. */
         width: number;
         /** height of the kernel in pixels. */
@@ -510,14 +510,14 @@ declare namespace sharp {
         offset?: number;
     }
 
-    export interface ThresholdOptions {
+    interface ThresholdOptions {
         /** convert to single channel greyscale. (optional, default true) */
         greyscale?: boolean;
         /** alternative spelling for greyscale. (optional, default true) */
         grayscale?: boolean;
     }
 
-    export interface OverlayOptions {
+    interface OverlayOptions {
         /** gravity at which to place the overlay. (optional, default 'centre') */
         gravity?: number;
         /** the pixel offset from the top edge. */
@@ -532,7 +532,7 @@ declare namespace sharp {
         raw?: Raw;
     }
 
-    export interface TileOptions {
+    interface TileOptions {
         /** Tile size in pixels, a value between 1 and 8192. (optional, default 256) */
         size?: number;
         /** Tile overlap in pixels, a value between 0 and 8192. (optional, default 0) */
@@ -543,7 +543,7 @@ declare namespace sharp {
         layout?: string;
     }
 
-    export interface OutputInfo {
+    interface OutputInfo {
         format: string;
         size: number;
         width: number;
@@ -551,19 +551,19 @@ declare namespace sharp {
         channels: number;
     }
 
-    export interface AvailableFormatInfo {
+    interface AvailableFormatInfo {
         id: string;
         input: { file: boolean; buffer: boolean; stream: boolean; };
         output: { file: boolean; buffer: boolean; stream: boolean; };
     }
 
-    export interface KernelEnum {
+    interface KernelEnum {
         cubic: string;
         lanczos2: string;
         lanczos3: string;
     }
 
-    export interface InterpolatorEnum {
+    interface InterpolatorEnum {
         nearest: string;
         bilinear: string;
         bicubic: string;
@@ -574,13 +574,13 @@ declare namespace sharp {
         vertexSplitQuadraticBasisSpline: string;
     }
 
-    export interface BoolEnum {
+    interface BoolEnum {
         and: string;
         or: string;
         eor: string;
     }
 
-    export interface ColourspaceEnum {
+    interface ColourspaceEnum {
         multiband: string;
         "b-w": string;
         bw: string;
@@ -588,7 +588,7 @@ declare namespace sharp {
         srgb: string;
     }
 
-    export interface GravityEnum {
+    interface GravityEnum {
         north: number;
         northeast: number;
         southeast: number;
@@ -601,12 +601,12 @@ declare namespace sharp {
         centre: number;
     }
 
-    export interface StrategyEnum {
+    interface StrategyEnum {
         entropy: number;
         attention: number;
     }
 
-    export interface FormatEnum {
+    interface FormatEnum {
         jpeg: AvailableFormatInfo;
         png: AvailableFormatInfo;
         webp: AvailableFormatInfo;
@@ -632,11 +632,11 @@ declare namespace sharp {
         (): FormatEnum;
     }
 
-    export interface CacheResult {
+    interface CacheResult {
         memory: { current: number; high: number; max: number; };
         files: { current: number; max: number; };
         items: { current: number; max: number; };
     }
 }
 
-export = sharp;
\ No newline at end of file
+export = sharp;
diff --git a/sharp/tsconfig.json b/sharp/tsconfig.json
index d896ff0b33..a7b4e6b9d6 100644
--- a/sharp/tsconfig.json
+++ b/sharp/tsconfig.json
@@ -5,9 +5,9 @@
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,
-        "baseUrl": "types",
+        "baseUrl": "../",
         "typeRoots": [
-            "types"
+            "../"
         ],
         "types": [],
         "noEmit": true,

From c52ae152ef4ee51247da5a70d29756591233f787 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Nguyen?=
 <lith-light-g@users.noreply.github.com>
Date: Fri, 27 Jan 2017 21:20:25 +0100
Subject: [PATCH 73/87] Use "lib" in tsconfigs instead of "target".

---
 sharp/index.d.ts    | 8 --------
 sharp/tsconfig.json | 4 +++-
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/sharp/index.d.ts b/sharp/index.d.ts
index 119e1d9b10..ef2026a782 100644
--- a/sharp/index.d.ts
+++ b/sharp/index.d.ts
@@ -624,14 +624,6 @@ declare namespace sharp {
         v: AvailableFormatInfo;
     }
 
-    interface FormatObject extends FormatEnum {
-        /**
-         * Returns an Object containing nested boolean values representing the available input and output formats/methods.
-         * @returns Object containing available formats
-         */
-        (): FormatEnum;
-    }
-
     interface CacheResult {
         memory: { current: number; high: number; max: number; };
         files: { current: number; max: number; };
diff --git a/sharp/tsconfig.json b/sharp/tsconfig.json
index a7b4e6b9d6..eafee068c7 100644
--- a/sharp/tsconfig.json
+++ b/sharp/tsconfig.json
@@ -1,7 +1,9 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "target": "es6",
+        "lib": [
+            "es6"
+        ],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,

From d79f340d574873ca4deabd545ee4b9fdab1164ec Mon Sep 17 00:00:00 2001
From: Kanchalai Tanglertsampan <yuisu@microsoft.com>
Date: Fri, 27 Jan 2017 15:23:51 -0800
Subject: [PATCH 74/87] Add tests and fix broken test

---
 react-day-picker/index.d.ts                    |  2 +-
 react-dom/index.d.ts                           |  4 ++--
 react-input-mask/index.d.ts                    |  2 +-
 react-native-scrollable-tab-view/index.d.ts    | 18 +++++++++---------
 .../react-native-swiper-tests.tsx              |  2 +-
 react/index.d.ts                               |  4 ++--
 react/test/tsx.tsx                             |  3 +++
 7 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/react-day-picker/index.d.ts b/react-day-picker/index.d.ts
index 01c5492922..f2993d95c5 100644
--- a/react-day-picker/index.d.ts
+++ b/react-day-picker/index.d.ts
@@ -75,7 +75,7 @@ declare namespace ReactDayPicker {
         toMonth?: Date;
         localeUtils?: LocaleUtils;
         locale?: string;
-        captionElement?: React.ReactElement<CaptionElementProps>;
+        captionElement?: React.ReactElement<CaptionElementProps> | null;
         onDayClick?: (e: React.SyntheticEvent<{}>, day: Date, modifiers: DayModifiers) => any;
         onDayTouchTap?: (e: React.SyntheticEvent<{}>, day: Date, modifiers: DayModifiers) => any;
         onDayMouseEnter?: (e: React.SyntheticEvent<{}>, day: Date, modifiers: DayModifiers) => any;
diff --git a/react-dom/index.d.ts b/react-dom/index.d.ts
index 00520fc6ed..bf0a246211 100644
--- a/react-dom/index.d.ts
+++ b/react-dom/index.d.ts
@@ -28,7 +28,7 @@ declare namespace ReactDOM {
         container: Element | null,
         callback?: (component: T) => any): T;
     function render<P>(
-        element: ReactElement<P>,
+        element: ReactElement<P> | null,
         container: Element | null,
         callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
 
@@ -57,7 +57,7 @@ declare namespace ReactDOM {
         callback?: () => any): void;
     function unstable_renderSubtreeIntoContainer<P>(
         parentComponent: Component<any, any>,
-        element: ReactElement<P>,
+        element: ReactElement<P> | null,
         container: Element,
         callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
 }
diff --git a/react-input-mask/index.d.ts b/react-input-mask/index.d.ts
index 6fc8c6008f..c6acce5858 100644
--- a/react-input-mask/index.d.ts
+++ b/react-input-mask/index.d.ts
@@ -13,7 +13,7 @@ declare namespace reactInputMask {
          * * `9`: `0-9`
          * * `a`: `A-Z, a-z`
          * * `\*`: `A-Z, a-z, 0-9`
-         * 
+         *
          * Any character can be escaped with backslash, which usually will appear as double backslash in JS strings. For example, German phone mask with unremoveable prefix +49 will look like `mask="+4\\9 99 999 99"` or `mask={"+4\\\\9 99 999 99"}`
          */
         mask: string;
diff --git a/react-native-scrollable-tab-view/index.d.ts b/react-native-scrollable-tab-view/index.d.ts
index 2f22f1bcf4..9287ede79d 100644
--- a/react-native-scrollable-tab-view/index.d.ts
+++ b/react-native-scrollable-tab-view/index.d.ts
@@ -37,9 +37,9 @@ export interface renderTabBarProperties {
 interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
 
   /**
-   * tabBarPosition (String) Defaults to "top". 
+   * tabBarPosition (String) Defaults to "top".
    * "bottom" to position the tab bar below content.
-   * "overlayTop" or "overlayBottom" for a semitransparent tab bar that overlays content. Custom 
+   * "overlayTop" or "overlayBottom" for a semitransparent tab bar that overlays content. Custom
    * tab bars must consume a style prop on their outer element to support this feature: style={this.props.style}.
    */
   tabBarPosition?: 'top' | 'bottom' | 'overlayTop' | 'overlayBottom';
@@ -50,27 +50,27 @@ interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
   initialPage?: number;
 
   /**
-   * (Integer) - set selected tab(can be buggy see 
+   * (Integer) - set selected tab(can be buggy see
    * https://github.com/skv-headless/react-native-scrollable-tab-view/issues/126
    */
   page?: number;
 
   /**
-   * onChangeTab (Function) - function to call when tab changes, should accept 1 argument which is 
-   * an Object containing two keys: i: the index of the tab that is selected, ref: the ref of the 
+   * onChangeTab (Function) - function to call when tab changes, should accept 1 argument which is
+   * an Object containing two keys: i: the index of the tab that is selected, ref: the ref of the
    * tab that is selected
    */
   onChangeTab?: (value: onChangeTabProperties) => void;
 
   /**
-   * onScroll (Function) - function to call when the pages are sliding, 
+   * onScroll (Function) - function to call when the pages are sliding,
    * should accept 1 argument which is an Float number representing the page position in the slide frame.
    */
   onScroll?: (value: number) => void;
 
   /**
    * renderTabBar (Function:ReactComponent) - accept 1 argument props and should return a component
-   * to use as the tab bar. The component has goToPage, tabs, activeTab and ref added to the props, 
+   * to use as the tab bar. The component has goToPage, tabs, activeTab and ref added to the props,
    * and should implement setAnimationValue to be able to animate itself along with the tab content.
    * You can manually pass the props to the TabBar component.
    */
@@ -82,7 +82,7 @@ interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
   style?: ViewStyle;
 
   /**
-   * contentProps (Object) - props that are applied to root ScrollView/ViewPagerAndroid. 
+   * contentProps (Object) - props that are applied to root ScrollView/ViewPagerAndroid.
    * Note that overriding defaults set by the library may break functionality; see the source for details.
    */
   contentProps?: React.ScrollViewProperties;
@@ -98,7 +98,7 @@ interface ScrollableTabViewProperties extends React.Props<ScrollableTabView> {
   locked?: boolean;
 
   /**
-   * prerenderingSiblingsNumber (Integer) - pre-render nearby # sibling, Infinity === render all 
+   * prerenderingSiblingsNumber (Integer) - pre-render nearby # sibling, Infinity === render all
    * the siblings, default to 0 === render current page.
    */
   prerenderingSiblingsNumber?: number;
diff --git a/react-native-swiper/react-native-swiper-tests.tsx b/react-native-swiper/react-native-swiper-tests.tsx
index 93cdfcfd18..c8dae8511e 100644
--- a/react-native-swiper/react-native-swiper-tests.tsx
+++ b/react-native-swiper/react-native-swiper-tests.tsx
@@ -18,7 +18,7 @@ class SwiperTest extends React.Component<IProperties, IState> {
     super(props);
   }
 
-  public render(): React.ReactElement<any> {
+  public render(): React.ReactElement<any> | null {
     return (
       <Swiper
         style={styles.wrapper}>
diff --git a/react/index.d.ts b/react/index.d.ts
index 6f88127305..61aa81ab01 100644
--- a/react/index.d.ts
+++ b/react/index.d.ts
@@ -168,7 +168,7 @@ declare namespace React {
         setState<K extends keyof S>(f: (prevState: S, props: P) => Pick<S, K>, callback?: () => any): void;
         setState<K extends keyof S>(state: Pick<S, K>, callback?: () => any): void;
         forceUpdate(callBack?: () => any): void;
-        render(): JSX.Element | null;
+        render(): JSX.Element;
 
         // React.Props<T> is now deprecated, which means that the `children`
         // property is not available on `P` by default, even though you can
@@ -2624,7 +2624,7 @@ declare global {
         type Element = JSXElement | null;
 
         interface ElementClass extends React.Component<any, any> {
-            render(): JSX.Element | null;
+            render(): JSX.Element;
         }
         interface ElementAttributesProperty { props: {}; }
 
diff --git a/react/test/tsx.tsx b/react/test/tsx.tsx
index 0531cb52c0..0b0bc096ae 100644
--- a/react/test/tsx.tsx
+++ b/react/test/tsx.tsx
@@ -32,3 +32,6 @@ StatelessComponent2.defaultProps = {
         </text>
     </g>
 </svg>;
+
+const CustomComponent = (props: { flag: boolean }) => props.flag ? React.createElement('div') : null;
+const UseComponent2 = (f: boolean) => <CustomComponent flag={f} />;

From 7a05f51b8d4078f5a20057550a4d0fcbcd0d2771 Mon Sep 17 00:00:00 2001
From: Gregor MacDougall <gregor@freerunningtechnologies.com>
Date: Fri, 27 Jan 2017 21:53:38 -0500
Subject: [PATCH 75/87] Correct Jest toBeCloseTo signature

In Jest .toBeCloseTo's second parameter is optional with a default of 5.

See:
https://facebook.github.io/jest/docs/api.html#tobeclosetonumber-numdigits

This updates the type definition to make this parameter optional as
well.
---
 jest/index.d.ts    | 2 +-
 jest/jest-tests.ts | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index f376ea5bcc..cb25dcc758 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -117,7 +117,7 @@ declare namespace jest {
         toBe(expected: any): void;
         toBeCalled(): void;
         toBeCalledWith(...args: any[]): void;
-        toBeCloseTo(expected: number, delta: number): void;
+        toBeCloseTo(expected: number, delta?: number): void;
         toBeDefined(): void;
         toBeFalsy(): void;
         toBeGreaterThan(expected: number): void;
diff --git a/jest/jest-tests.ts b/jest/jest-tests.ts
index 913a671fa1..4f54d44236 100644
--- a/jest/jest-tests.ts
+++ b/jest/jest-tests.ts
@@ -147,6 +147,10 @@ describe('compartion', function () {
     it('works sanely with simple decimals', function () {
         expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
     });
+
+    it('works sanely with simple decimals and the default delta', function () {
+        expect(0.2 + 0.1).toBeCloseTo(0.3);
+    });
 });
 
 describe('toThrow API', function () {

From 1043ffe71c4cdea7f0a0e97f022e70c018e1e01f Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@isache.com>
Date: Fri, 27 Jan 2017 08:49:48 +0200
Subject: [PATCH 76/87] Steed - declare namespace and modify tests

---
 steed/index.d.ts     |  79 +++++++++++++-------------
 steed/steed-tests.ts | 129 +++++++++++++++++--------------------------
 2 files changed, 92 insertions(+), 116 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index f88669e92c..ba4b199999 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,48 +3,49 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T; }
-interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void; }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+declare namespace steed {
+    interface Dictionary<T> { [key: string]: T; }
+    interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+    interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+    interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+    interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedQueue<T> {
-    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    pause(): void;
-    resume(): void;
-    idle(): boolean;
-    length(): number;
-    kill(): void;
-    concurrency: number;
-    drain: () => any;
-    empty: () => any;
-    saturated: () => any;
+    interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+    interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+    interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+    interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+
+    interface SteedQueue<T> {
+        push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+        unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+        pause(): void;
+        resume(): void;
+        idle(): boolean;
+        length(): number;
+        kill(): void;
+        concurrency: number;
+        drain: () => any;
+        empty: () => any;
+        saturated: () => any;
+    }
+
+    interface Steed {
+        parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+        each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+        eachSeries: typeof steed.each;
+        map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+        mapSeries: typeof steed.map;
+        queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+        queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
+    }
 }
 
-interface Steed {
-    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    mapSeries: typeof steed.map;
-    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
-}
+declare const steed: steed.Steed;
 
-declare const steed: Steed;
-
-declare module "steed" {
-    export = steed;
-}
+export = steed;
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 729e59472f..685654cc52 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -1,19 +1,14 @@
 /// <reference types="node" />
 
-import fs = require("fs");
-import process = require("process");
+import steed = require('steed')
 
 declare var path: {
-    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
+    exists: (path: string, callback?: (error: Error, exists: boolean) => any) => void;
 };
 
-function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
+function funcStringCbErrBoolean(v: string, cb: (error: Error, res: boolean) => void) { }
 function callback() { }
 
-steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-
-
 steed.parallel([
     function () { },
     function () { }
@@ -25,16 +20,16 @@ steed.series([
 ]);
 
 var data: any[] = [];
-function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
-steed.map(data, steedProcess, function (err, results) {
+function steedProcess(item: any, callback: (error: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (error, results) {
     console.log(results);
 });
 
 var openFiles = ['file1', 'file2'];
 
-var saveFile = function (file:string,cb:(err:Error)=>void) { }
-steed.each(openFiles, saveFile, function (err:Error) { });
-steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+var saveFile = function (file: string, cb: (error: Error) => void) { }
+steed.each(openFiles, saveFile, function (error: Error) { });
+steed.eachSeries(openFiles, saveFile, function (error: Error) { });
 
 // Control Flow //
 
@@ -46,9 +41,9 @@ steed.series([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<string,Error>([
+steed.series<string, Error>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -56,7 +51,7 @@ steed.series<string,Error>([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 steed.series({
     one: function (callback) {
@@ -70,9 +65,9 @@ steed.series({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<number,Error>({
+steed.series<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -84,7 +79,7 @@ steed.series<number,Error>({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
 steed.parallel([
     function (callback) {
@@ -98,9 +93,9 @@ steed.parallel([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<string,Error>([
+steed.parallel<string, Error>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -112,7 +107,7 @@ steed.parallel<string,Error>([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 
 steed.parallel({
@@ -127,9 +122,9 @@ steed.parallel({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<number,Error>({
+steed.parallel<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -141,7 +136,7 @@ steed.parallel<number,Error>({
         }, 100);
     },
 },
-    function (err, results) { });
+    function (error, results) { });
 
 function whileFn(callback: any) {
     count++;
@@ -161,10 +156,10 @@ steed.waterfall([
     function (arg1: any, callback: any) {
         callback(null, 'done');
     }
-], function (err, result) { });
+], function (error, result) { });
 
 
-var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+var q = steed.queue<any, Error>(function (task: any, callback: () => void) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -180,7 +175,7 @@ q.push({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
@@ -190,22 +185,22 @@ q.unshift({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
-var qLength : number = q.length();
-var qIsIdle : boolean = q.idle();
+var qLength: number = q.length();
+var qIsIdle: boolean = q.idle();
 
-q.saturated = function() {
+q.saturated = function () {
     console.log('queue is saturated.');
 }
 
-q.empty = function() {
+q.empty = function () {
     console.log('queue is empty.');
 }
 
-q.drain = function() {
+q.drain = function () {
     console.log('queue was drained.');
 }
 
@@ -214,7 +209,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = steed.queue<string, Error>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -225,7 +220,7 @@ q2.push('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.push(['task3', 'task4', 'task5'], function (error) {
+q2.push(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
@@ -235,49 +230,29 @@ q2.unshift('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.unshift(['task3', 'task4', 'task5'], function (error) {
+q2.unshift(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
-
-// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-//     console.log('hello ' + level);
-//     callback(null, level+1);
-// });
-//
-// aq.push(1, function (err : Error, newLevel : number) {
-//     console.log('finished processing bar' + newLevel);
-// });
-
-
 steed.parallel([
-    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback: (error: Error, val: string) => void) { },
     function (callback) { }
 ],
-function (err:Error,results:Array<string>) {
-    steed.series([
-        function (callback) { },
-        function email_link(callback) { }
-    ]);
-});
-
-steed.parallel([
-    function (callback) {
-        fs.writeFile('testfile1', 'test1', callback);
-    },
-    function (callback) {
-        fs.writeFile('testfile2', 'test2', callback);
-    },
-]);
+    function (error: Error, results: Array<string>) {
+        steed.series([
+            function (callback) { },
+            function email_link(callback) { }
+        ]);
+    });
 
 // each
 
-steed.each<number,Error>({
+steed.each<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.each: ${val}`);
 
@@ -285,7 +260,7 @@ steed.each<number,Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.each: done.");
 
@@ -294,9 +269,9 @@ steed.each<number,Error>({
 steed.eachSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.eachSeries: ${val}`);
 
@@ -304,7 +279,7 @@ steed.eachSeries<number, Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.eachSeries: done.");
 
@@ -316,9 +291,9 @@ steed.map<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.map: ${val}`);
 
@@ -326,7 +301,7 @@ steed.map<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.map: done with results", results);
 
@@ -336,9 +311,9 @@ steed.mapSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.mapSeries: ${val}`);
 
@@ -346,7 +321,7 @@ steed.mapSeries<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.mapSeries: done with results", results);
 

From 65131e2649dd9ae86214634cd66056d2c791e712 Mon Sep 17 00:00:00 2001
From: Sander Koenders <sanderkoenders@gmail.com>
Date: Sat, 28 Jan 2017 22:56:51 +0100
Subject: [PATCH 77/87] Added ns-api typings

---
 ns-api/index.d.ts      | 66 ++++++++++++++++++++++++++++++++++++++++++
 ns-api/ns-api-tests.ts | 56 +++++++++++++++++++++++++++++++++++
 ns-api/tsconfig.json   | 20 +++++++++++++
 ns-api/tslint.json     |  1 +
 4 files changed, 143 insertions(+)
 create mode 100644 ns-api/index.d.ts
 create mode 100644 ns-api/ns-api-tests.ts
 create mode 100644 ns-api/tsconfig.json
 create mode 100644 ns-api/tslint.json

diff --git a/ns-api/index.d.ts b/ns-api/index.d.ts
new file mode 100644
index 0000000000..db66f109f3
--- /dev/null
+++ b/ns-api/index.d.ts
@@ -0,0 +1,66 @@
+// Type definitions for ns-api 2.0
+// Project: https://github.com/fvdm/nodejs-ns-api#readme
+// Definitions by: Sander Koenders <https://github.com/Archcry>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = nsApi;
+declare function nsApi(conf: nsApi.Configuration): nsApi;
+
+interface nsApi {
+    /**
+     * Vertrektijden - departure times
+     *
+     * @callback callback
+     * @param station {string} - Station ID
+     * @param callback {function} - `function (err, data) {}`
+     * @returns {void}
+     */
+    vertrektijden(station: string, callback: (err: string, data: {}) => void): void;
+
+    /**
+     * Reisadvies - travel advise
+     *
+     * @callback callback
+     * @param params {object} - Parameters
+     * @param callback {function} - `function (err, data) {}`
+     * @returns {void}
+     */
+    reisadvies(params: {}, callback: (err: string, data: {}) => void): void;
+
+    /**
+     * Prijzen - tariffs
+     *
+     * @callback callback
+     * @param params {object} - Parameters
+     * @param callback {function} - `function (err, data) {}`
+     * @returns {void}
+     */
+    prijzen(params: {}, callback: (err: any, data: {}) => void): void;
+
+    /**
+     * List available stations
+     *
+     * @callback callback
+     * @param [treeKey] {string} - Group by this key
+     * @param callback {function} - `function (err, data) {}`
+     */
+    stations(treeKey: string, callback: (err: string, data: {}) => void): void;
+    stations(callback: (err: string, data: {}) => void): void;
+
+    /**
+     * List disruptions
+     *
+     * @callback callback
+     * @param params {object} - Parameters
+     * @param callback {function} - `function (err, data) {}`
+     */
+    storingen(params: {}, callback: (err: string, data: {}) => void): void;
+}
+
+declare namespace nsApi {
+    interface Configuration {
+        username: string;
+        password: string;
+        timeout?: number;
+    }
+}
diff --git a/ns-api/ns-api-tests.ts b/ns-api/ns-api-tests.ts
new file mode 100644
index 0000000000..8a3b8c5bb6
--- /dev/null
+++ b/ns-api/ns-api-tests.ts
@@ -0,0 +1,56 @@
+import * as NsApi from "ns-api";
+
+let ns: NsApi = NsApi({
+    username: "",
+    password: "",
+    timeout: 1500
+});
+
+ns.vertrektijden("", (err: any, data: Object) => {
+    if(err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
+
+// Get travel advise
+ns.reisadvies ({}, (err: any, data: Object) => {
+    if(err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
+
+ns.prijzen({}, (err: any, data: Object) => {
+    if(err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
+
+ns.stations("code", (err: any, data: Object) => {
+    if(err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
+
+ns.stations((err: any, data: Object) => {
+    if(err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
+
+ns.storingen({}, (err: any, data: Object) => {
+    if(err) {
+        console.log(err);
+    } else {
+        console.log(data);
+    }
+});
\ No newline at end of file
diff --git a/ns-api/tsconfig.json b/ns-api/tsconfig.json
new file mode 100644
index 0000000000..fae5845b2d
--- /dev/null
+++ b/ns-api/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "ns-api-tests.ts"
+    ]
+}
diff --git a/ns-api/tslint.json b/ns-api/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/ns-api/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 556c7a325edfb519d1a528d29d91efaa47d8d98d Mon Sep 17 00:00:00 2001
From: Benjamin Lim <bumbleblym@gmail.com>
Date: Sun, 29 Jan 2017 06:13:01 +0800
Subject: [PATCH 78/87] feat: lodash-webpack-plugin

---
 lodash-webpack-plugin/index.d.ts              | 34 +++++++++++++++++++
 .../lodash-webpack-plugin-tests.ts            | 27 +++++++++++++++
 lodash-webpack-plugin/tsconfig.json           | 20 +++++++++++
 lodash-webpack-plugin/tslint.json             |  1 +
 4 files changed, 82 insertions(+)
 create mode 100644 lodash-webpack-plugin/index.d.ts
 create mode 100644 lodash-webpack-plugin/lodash-webpack-plugin-tests.ts
 create mode 100644 lodash-webpack-plugin/tsconfig.json
 create mode 100644 lodash-webpack-plugin/tslint.json

diff --git a/lodash-webpack-plugin/index.d.ts b/lodash-webpack-plugin/index.d.ts
new file mode 100644
index 0000000000..26d633e79f
--- /dev/null
+++ b/lodash-webpack-plugin/index.d.ts
@@ -0,0 +1,34 @@
+// Type definitions for lodash-webpack-plugin 0.11
+// Project: https://github.com/lodash/lodash-webpack-plugin#readme
+// Definitions by: Benjamin Lim <https://github.com/bumbleblym>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { Plugin, Webpack } from 'webpack';
+
+export = LodashModuleReplacementPlugin;
+
+declare class LodashModuleReplacementPlugin implements Plugin {
+	constructor(options?: LodashModuleReplacementPlugin.Options);
+	apply(thisArg: Webpack, ...args: any[]): void;
+}
+
+declare namespace LodashModuleReplacementPlugin {
+	export interface Options {
+		caching?: boolean;
+		chaining?: boolean;
+		cloning?: boolean;
+		coercions?: boolean;
+		collections?: boolean;
+		currying?: boolean;
+		deburring?: boolean;
+		exotics?: boolean;
+		flattening?: boolean;
+		guards?: boolean;
+		memoizing?: boolean;
+		metadata?: boolean;
+		paths?: boolean;
+		placeholders?: boolean;
+		shorthands?: boolean;
+		unicode?: boolean;
+	}
+}
diff --git a/lodash-webpack-plugin/lodash-webpack-plugin-tests.ts b/lodash-webpack-plugin/lodash-webpack-plugin-tests.ts
new file mode 100644
index 0000000000..cd893f09f0
--- /dev/null
+++ b/lodash-webpack-plugin/lodash-webpack-plugin-tests.ts
@@ -0,0 +1,27 @@
+import * as LodashModuleReplacementPlugin from 'lodash-webpack-plugin'
+
+new LodashModuleReplacementPlugin()
+
+new LodashModuleReplacementPlugin({
+	collections: true,
+	paths: true,
+})
+
+new LodashModuleReplacementPlugin({
+	caching: true,
+	chaining: true,
+	cloning: true,
+	coercions: true,
+	collections: true,
+	currying: true,
+	deburring: true,
+	exotics: true,
+	flattening: true,
+	guards: true,
+	memoizing: true,
+	metadata: true,
+	paths: true,
+	placeholders: true,
+	shorthands: true,
+	unicode: true,
+})
diff --git a/lodash-webpack-plugin/tsconfig.json b/lodash-webpack-plugin/tsconfig.json
new file mode 100644
index 0000000000..03e491ef78
--- /dev/null
+++ b/lodash-webpack-plugin/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "lodash-webpack-plugin-tests.ts"
+    ]
+}
diff --git a/lodash-webpack-plugin/tslint.json b/lodash-webpack-plugin/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/lodash-webpack-plugin/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From e52af758df95a81cca186b866742a3e8461757be Mon Sep 17 00:00:00 2001
From: Olmo del Corral <olmo@signumsoftware.com>
Date: Mon, 30 Jan 2017 07:50:58 +0100
Subject: [PATCH 79/87] add justified to tabs

---
 react-bootstrap/index.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/react-bootstrap/index.d.ts b/react-bootstrap/index.d.ts
index 3e5c69c034..e211264bc7 100644
--- a/react-bootstrap/index.d.ts
+++ b/react-bootstrap/index.d.ts
@@ -606,6 +606,7 @@ declare namespace ReactBootstrap {
         position?: string;
         tabWidth?: any; // TODO: Add more specific type
         unmountOnExit?: boolean;
+        justified?: boolean;
     }
     type Tabs = React.ClassicComponent<TabsProps, {}>;
     var Tabs: React.ClassicComponentClass<TabsProps>;

From c1faa58a1a3aa3fe066f30c2b965b71642821dc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsolt=20Kov=C3=A1cs?= <k.zsolt@live.com>
Date: Mon, 30 Jan 2017 10:49:02 +0100
Subject: [PATCH 80/87] Add type definitions for dragster

---
 dragster/dragster-tests.ts |  7 +++++++
 dragster/index.d.ts        | 12 ++++++++++++
 dragster/tsconfig.json     | 23 +++++++++++++++++++++++
 3 files changed, 42 insertions(+)
 create mode 100644 dragster/dragster-tests.ts
 create mode 100644 dragster/index.d.ts
 create mode 100644 dragster/tsconfig.json

diff --git a/dragster/dragster-tests.ts b/dragster/dragster-tests.ts
new file mode 100644
index 0000000000..e6dea2fd98
--- /dev/null
+++ b/dragster/dragster-tests.ts
@@ -0,0 +1,7 @@
+import Dragster = require("dragster");
+
+var dropzone = document.getElementById("my-dropzone");
+var dragster = new Dragster(dropzone);
+
+dragster.removeListeners();
+dragster.reset();
\ No newline at end of file
diff --git a/dragster/index.d.ts b/dragster/index.d.ts
new file mode 100644
index 0000000000..297096bd26
--- /dev/null
+++ b/dragster/index.d.ts
@@ -0,0 +1,12 @@
+// Type definitions for dragster 0.1.3
+// Project: https://github.com/bensmithett/dragster
+// Definitions by: Zsolt Kovacs <https://github.com/zskovacs>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare class Dragster {
+    constructor(elem: HTMLElement);
+    removeListeners(): void;
+    reset(): void;
+}
+
+export = Dragster;
\ No newline at end of file
diff --git a/dragster/tsconfig.json b/dragster/tsconfig.json
new file mode 100644
index 0000000000..600f1bed21
--- /dev/null
+++ b/dragster/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "dragster-tests.ts"
+    ]
+}
\ No newline at end of file

From d8320ed922b06d321342996f2c7d31e4f39ecf16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsolt=20Kov=C3=A1cs?= <k.zsolt@live.com>
Date: Mon, 30 Jan 2017 10:59:56 +0100
Subject: [PATCH 81/87] Add tslint.json

---
 dragster/tslint.json | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 dragster/tslint.json

diff --git a/dragster/tslint.json b/dragster/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/dragster/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

From 033a11cfee057225b1e5f3e192fb879236c5e688 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsolt=20Kov=C3=A1cs?= <k.zsolt@live.com>
Date: Mon, 30 Jan 2017 11:01:11 +0100
Subject: [PATCH 82/87] Set strictNullChecks to true

---
 dragster/tsconfig.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dragster/tsconfig.json b/dragster/tsconfig.json
index 600f1bed21..9740d729a0 100644
--- a/dragster/tsconfig.json
+++ b/dragster/tsconfig.json
@@ -7,7 +7,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"

From 83724cda4d9932e329971b6b713ec9571a88cb1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsolt=20Kov=C3=A1cs?= <k.zsolt@live.com>
Date: Mon, 30 Jan 2017 11:10:39 +0100
Subject: [PATCH 83/87] Fix test

---
 dragster/dragster-tests.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dragster/dragster-tests.ts b/dragster/dragster-tests.ts
index e6dea2fd98..a05d06e1dd 100644
--- a/dragster/dragster-tests.ts
+++ b/dragster/dragster-tests.ts
@@ -1,6 +1,6 @@
 import Dragster = require("dragster");
 
-var dropzone = document.getElementById("my-dropzone");
+var dropzone = document.getElementById("my-dropzone") as HTMLElement;
 var dragster = new Dragster(dropzone);
 
 dragster.removeListeners();

From 666f54833ab821abb8170adbd7c481def566ff0e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsolt=20Kov=C3=A1cs?= <k.zsolt@live.com>
Date: Mon, 30 Jan 2017 11:17:31 +0100
Subject: [PATCH 84/87] Fix header

---
 dragster/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dragster/index.d.ts b/dragster/index.d.ts
index 297096bd26..997c641d54 100644
--- a/dragster/index.d.ts
+++ b/dragster/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for dragster 0.1.3
+// Type definitions for dragster
 // Project: https://github.com/bensmithett/dragster
 // Definitions by: Zsolt Kovacs <https://github.com/zskovacs>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

From a2953a73ed8299e882f7c1751c73195a0f502e84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zsolt=20Kov=C3=A1cs?= <k.zsolt@live.com>
Date: Mon, 30 Jan 2017 11:20:23 +0100
Subject: [PATCH 85/87] Another fix for header

---
 dragster/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dragster/index.d.ts b/dragster/index.d.ts
index 997c641d54..d60892244e 100644
--- a/dragster/index.d.ts
+++ b/dragster/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for dragster
+// Type definitions for dragster 0.1
 // Project: https://github.com/bensmithett/dragster
 // Definitions by: Zsolt Kovacs <https://github.com/zskovacs>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

From 9964163a159f93d68a249edec01900d0fe416f96 Mon Sep 17 00:00:00 2001
From: orta <orta.therox@gmail.com>
Date: Mon, 30 Jan 2017 15:09:05 -0500
Subject: [PATCH 86/87] Add more comments to Jest, and bump version to 18.1.0

---
 jest/index.d.ts | 52 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/jest/index.d.ts b/jest/index.d.ts
index 401f9ecb0e..b0b53625bb 100644
--- a/jest/index.d.ts
+++ b/jest/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Jest 18.0.0
+// Type definitions for Jest 18.1.0
 // Project: http://facebook.github.io/jest/
 // Definitions by: Asana <https://asana.com>, Ivo Stratev <https://github.com/NoHomey>, jwbay <https://github.com/jwbay>, Alexey Svetliakov <https://github.com/asvetliakov>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -27,6 +27,7 @@ interface NodeRequire {
 }
 
 declare namespace jest {
+    /** Provides a way to add Jasmine-compatible matchers into your Jest context. */
     function addMatchers(matchers: jasmine.CustomMatcherFactories): typeof jest;
     /** Disables automatic mocking in the module loader. */
     function autoMockOff(): typeof jest;
@@ -104,8 +105,16 @@ declare namespace jest {
         (fn: ProvidesCallback): any;
     }
 
+    /** Creates a test closure */
     interface It {
+        /**
+         * Creates a test closure.
+         * 
+         * @param {string} name The name of your test
+         * @param {fn?} ProvidesCallback The function for your test
+         */
         (name: string, fn?: ProvidesCallback): void;
+        /** Only runs this test in the current file. */
         only: It;
         skip: It;
         concurrent: It;
@@ -141,48 +150,89 @@ declare namespace jest {
         [key: string]: (this: MatcherUtils, received: any, actual: any) => { message: () => string, pass: boolean };
     }
 
+    /** The `expect` function is used every time you want to test a value. You will rarely call `expect` by itself. */
     interface Expect {
+        /** 
+         * The `expect` function is used every time you want to test a value. You will rarely call `expect` by itself. 
+         * 
+         * @param {any} actual The value to apply matchers against.
+        */
         (actual: any): Matchers;
         anything(): void;
+        /** Matches anything that was created with the given constructor. You can use it inside `toEqual` or `toBeCalledWith` instead of a literal value. */
         any(classType: any): void;
+        /** Matches any array made up entirely of elements in the provided array. You can use it inside `toEqual` or `toBeCalledWith` instead of a literal value.  */
         arrayContaining(arr: any[]): void;
+        /** Verifies that a certain number of assertions are called during a test. This is often useful when testing asynchronous code, in order to make sure that assertions in a callback actually got called. */
         assertions(num: number): void;
+        /** You can use `expect.extend` to add your own matchers to Jest. */
         extend(obj: ExpectExtendMap): void;
+        /** Matches any object that recursively matches the provided keys. This is often handy in conjunction with other asymmetric matchers. */
         objectContaining(obj: {}): void;
+        /** Matches any string that contains the exact provided string */
         stringMatching(str: string | RegExp): void;
     }
 
     interface Matchers {
+        /** If you know how to test something, `.not` lets you test its opposite. */
         not: Matchers;
         lastCalledWith(...args: any[]): void;
+        /** Checks that a value is what you expect. It uses `===` to check strict equality. Don't use `toBe` with floating-point numbers. */
         toBe(expected: any): void;
+        /** Ensures that a mock function is called. */
         toBeCalled(): void;
+        /** Ensure that a mock function is called with specific arguments. */
         toBeCalledWith(...args: any[]): void;
+        /** Using exact equality with floating point numbers is a bad idea. Rounding means that intuitive things fail. */
         toBeCloseTo(expected: number, delta?: number): void;
+        /** Ensure that a variable is not undefined. */
         toBeDefined(): void;
+        /** When you don't care what a value is, you just want to ensure a value is false in a boolean context. */
         toBeFalsy(): void;
+        /** For comparing floating point numbers. */
         toBeGreaterThan(expected: number): void;
+        /** For comparing floating point numbers. */
         toBeGreaterThanOrEqual(expected: number): void;
+        /** Ensure that an object is an instance of a class. This matcher uses `instanceof` underneath. */
         toBeInstanceOf(expected: any): void
+        /** For comparing floating point numbers. */
         toBeLessThan(expected: number): void;
+        /** For comparing floating point numbers. */
         toBeLessThanOrEqual(expected: number): void;
+        /** This is the same as `.toBe(null)` but the error messages are a bit nicer. So use `.toBeNull()` when you want to check that something is null. */
         toBeNull(): void;
+        /** Use when you don't care what a value is, you just want to ensure a value is true in a boolean context. In JavaScript, there are six falsy values: `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy. */
         toBeTruthy(): void;
+        /** Used to check that a variable is undefined. */
         toBeUndefined(): void;
+        /** Used when you want to check that an item is in a list. For testing the items in the list, this uses `===`, a strict equality check. */
         toContain(expected: any): void;
+        /** Used when you want to check that an item is in a list. For testing the items in the list, this  matcher recursively checks the equality of all fields, rather than checking for object identity. */
         toContainEqual(expected: any): void;
+        /** Used when you want to check that two objects have the same value. This matcher recursively checks the equality of all fields, rather than checking for object identity. */
         toEqual(expected: any): void;
+        /** Ensures that a mock function is called. */
         toHaveBeenCalled(): boolean;
+        /** Ensures that a mock function is called an exact number of times. */
         toHaveBeenCalledTimes(expected: number): boolean;
+        /** Ensure that a mock function is called with specific arguments. */
         toHaveBeenCalledWith(...params: any[]): boolean;
+        /** If you have a mock function, you can use `.toHaveBeenLastCalledWith` to test what arguments it was last called with. */
         toHaveBeenLastCalledWith(...params: any[]): boolean;
+        /** Used to check that an object has a `.length` property and it is set to a certain numeric value. */
         toHaveLength(expected: number): void;
         toHaveProperty(propertyPath: string, value?: any): void;
+        /** Check that a string matches a regular expression. */
         toMatch(expected: string | RegExp): void;
+        /** Used to check that a JavaScript object matches a subset of the properties of an objec */
         toMatchObject(expected: {}): void;
+        /** This ensures that a value matches the most recent snapshot. Check out [the Snapshot Testing guide](http://facebook.github.io/jest/docs/snapshot-testing.html) for more information. */
         toMatchSnapshot(snapshotName?: string): void;
+        /** Used to test that a function throws when it is called. */
         toThrow(): void;
+        /** If you want to test that a specific error is thrown inside a function. */
         toThrowError(error?: string | Constructable | RegExp): void;
+        /** Used to test that a function throws a error matching the most recent snapshot when it is called. */
         toThrowErrorMatchingSnapshot(): void;
     }
 

From ec9bf7f22990ed5c3d419356e263f595bef7eebb Mon Sep 17 00:00:00 2001
From: Patricio Zavolinsky <patricio.zavolinsky@emaint.com>
Date: Mon, 23 Jan 2017 10:48:46 +0000
Subject: [PATCH 87/87] React: Constrain typed changed events to inputs,
 selects and textareas

---
 react/index.d.ts    | 40 ++++++++++++++++++++++++----------------
 react/test/index.ts | 15 +++++++++++++++
 2 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/react/index.d.ts b/react/index.d.ts
index 61aa81ab01..f25e5c0afd 100644
--- a/react/index.d.ts
+++ b/react/index.d.ts
@@ -81,6 +81,9 @@ declare namespace React {
     interface HTMLFactory<T extends HTMLElement> extends DOMFactory<HTMLAttributes<T>, T> {
     }
 
+    interface ChangeTargetHTMLFactory<T extends HTMLElement> extends DOMFactory<ChangeTargetHTMLAttributes<T>, T> {
+    }
+
     interface SVGFactory extends DOMFactory<SVGAttributes<SVGElement>, SVGElement> {
     }
 
@@ -270,9 +273,10 @@ declare namespace React {
     //
     // Event System
     // ----------------------------------------------------------------------
-    interface SyntheticEventBase<CURRENT, TARGET> {
+
+    interface SyntheticEvent<T> {
         bubbles: boolean;
-        currentTarget: EventTarget & CURRENT;
+        currentTarget: EventTarget & T;
         cancelable: boolean;
         defaultPrevented: boolean;
         eventPhase: number;
@@ -283,16 +287,12 @@ declare namespace React {
         stopPropagation(): void;
         isPropagationStopped(): boolean;
         persist(): void;
-        target: EventTarget & TARGET;
+        // If you thought this should be `EventTarget & T`, see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/12239
+        target: EventTarget;
         timeStamp: Date;
         type: string;
     }
 
-    interface SyntheticEvent<T> extends SyntheticEventBase<T, EventTarget> {
-      // If you thought target should be `EventTarget & T`,
-      // see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/12239
-    }
-
     interface ClipboardEvent<T> extends SyntheticEvent<T> {
         clipboardData: DataTransfer;
     }
@@ -312,7 +312,8 @@ declare namespace React {
     interface FormEvent<T> extends SyntheticEvent<T> {
     }
 
-    interface ChangeEvent<T> extends SyntheticEventBase<T, T> {
+    interface ChangeEvent<T> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
     interface KeyboardEvent<T> extends SyntheticEvent<T> {
@@ -433,6 +434,9 @@ declare namespace React {
     interface HTMLProps<T> extends HTMLAttributes<T>, ClassAttributes<T> {
     }
 
+    interface ChangeTargetHTMLProps<T extends HTMLElement> extends ChangeTargetHTMLAttributes<T>, ClassAttributes<T> {
+    }
+
     interface SVGProps extends SVGAttributes<SVGElement>, ClassAttributes<SVGElement> {
     }
 
@@ -465,7 +469,7 @@ declare namespace React {
         onBlurCapture?: FocusEventHandler<T>;
 
         // Form Events
-        onChange?: ChangeEventHandler<T>;
+        onChange?: FormEventHandler<T>;
         onChangeCapture?: FormEventHandler<T>;
         onInput?: FormEventHandler<T>;
         onInputCapture?: FormEventHandler<T>;
@@ -2149,6 +2153,10 @@ declare namespace React {
         unselectable?: boolean;
     }
 
+    interface ChangeTargetHTMLAttributes<T extends HTMLElement> extends HTMLAttributes<T> {
+        onChange?: ChangeEventHandler<T>;
+    }
+
     // this list is "complete" in that it contains every SVG attribute
     // that React supports, but the types can be improved.
     // Full list here: https://facebook.github.io/react/docs/dom-elements.html
@@ -2459,7 +2467,7 @@ declare namespace React {
         i: HTMLFactory<HTMLElement>;
         iframe: HTMLFactory<HTMLIFrameElement>;
         img: HTMLFactory<HTMLImageElement>;
-        input: HTMLFactory<HTMLInputElement>;
+        input: ChangeTargetHTMLFactory<HTMLInputElement>;
         ins: HTMLFactory<HTMLModElement>;
         kbd: HTMLFactory<HTMLElement>;
         keygen: HTMLFactory<HTMLElement>;
@@ -2494,7 +2502,7 @@ declare namespace React {
         samp: HTMLFactory<HTMLElement>;
         script: HTMLFactory<HTMLElement>;
         section: HTMLFactory<HTMLElement>;
-        select: HTMLFactory<HTMLSelectElement>;
+        select: ChangeTargetHTMLFactory<HTMLSelectElement>;
         small: HTMLFactory<HTMLElement>;
         source: HTMLFactory<HTMLSourceElement>;
         span: HTMLFactory<HTMLSpanElement>;
@@ -2506,7 +2514,7 @@ declare namespace React {
         table: HTMLFactory<HTMLTableElement>;
         tbody: HTMLFactory<HTMLTableSectionElement>;
         td: HTMLFactory<HTMLTableDataCellElement>;
-        textarea: HTMLFactory<HTMLTextAreaElement>;
+        textarea: ChangeTargetHTMLFactory<HTMLTextAreaElement>;
         tfoot: HTMLFactory<HTMLTableSectionElement>;
         th: HTMLFactory<HTMLTableHeaderCellElement>;
         thead: HTMLFactory<HTMLTableSectionElement>;
@@ -2686,7 +2694,7 @@ declare global {
             i: React.HTMLProps<HTMLElement>;
             iframe: React.HTMLProps<HTMLIFrameElement>;
             img: React.HTMLProps<HTMLImageElement>;
-            input: React.HTMLProps<HTMLInputElement>;
+            input: React.ChangeTargetHTMLProps<HTMLInputElement>;
             ins: React.HTMLProps<HTMLModElement>;
             kbd: React.HTMLProps<HTMLElement>;
             keygen: React.HTMLProps<HTMLElement>;
@@ -2722,7 +2730,7 @@ declare global {
             samp: React.HTMLProps<HTMLElement>;
             script: React.HTMLProps<HTMLElement>;
             section: React.HTMLProps<HTMLElement>;
-            select: React.HTMLProps<HTMLSelectElement>;
+            select: React.ChangeTargetHTMLProps<HTMLSelectElement>;
             small: React.HTMLProps<HTMLElement>;
             source: React.HTMLProps<HTMLSourceElement>;
             span: React.HTMLProps<HTMLSpanElement>;
@@ -2734,7 +2742,7 @@ declare global {
             table: React.HTMLProps<HTMLTableElement>;
             tbody: React.HTMLProps<HTMLTableSectionElement>;
             td: React.HTMLProps<HTMLTableDataCellElement>;
-            textarea: React.HTMLProps<HTMLTextAreaElement>;
+            textarea: React.ChangeTargetHTMLProps<HTMLTextAreaElement>;
             tfoot: React.HTMLProps<HTMLTableSectionElement>;
             th: React.HTMLProps<HTMLTableHeaderCellElement>;
             thead: React.HTMLProps<HTMLTableSectionElement>;
diff --git a/react/test/index.ts b/react/test/index.ts
index b575055514..38ad574aa4 100644
--- a/react/test/index.ts
+++ b/react/test/index.ts
@@ -674,3 +674,18 @@ class SyntheticEventTargetValue extends React.Component<{}, { value: string }> {
     });
   }
 }
+
+React.DOM.input({
+    onChange: event => {
+        // `event.target` is guaranteed to be HTMLInputElement
+        event.target.value;
+    }
+});
+
+// A ChangeEvent is a valid FormEvent (maintain compatibility with existing
+// event handlers)
+
+type InputChangeEvent = React.ChangeEvent<HTMLInputElement>;
+type InputFormEvent = React.FormEvent<HTMLInputElement>;
+const changeEvent:InputChangeEvent = undefined as any;
+const formEvent:InputFormEvent = changeEvent;